[wpiunits] Java units API rewrite (#6958)

Java generics are too limited to do what we need. This refactors generic code previously in Unit and Measure into unit-specific classes that can have unit-safe math operations (notably, times and divide) that can return values in known units instead of a wildcarded Measure<?>.

Unit-specific measure implementations are automatically generated by ./wpiunits/generate_units.py, which generates generic interfaces and mutable and immutable implementations of those interfaces. These make up the bulk of the diff of this PR (approximately 9300 LOC).

This also adds units for angular and linear velocities, accelerations, and momenta; moment of inertia; and torque.

wpiunits/CMakeLists.txt

@@ -4,7 +4,7 @@ project(wpiunits)
 if(WITH_JAVA)
     include(UseJava)
 
-    file(GLOB_RECURSE JAVA_SOURCES src/main/java/*.java)
+    file(GLOB_RECURSE JAVA_SOURCES src/main/java/*.java src/generated/main/java/*.java)
 
     add_jar(
         wpiunits_jar
@@ -24,7 +24,9 @@ if(WITH_JAVA_SOURCE)
     include(CreateSourceJar)
     add_source_jar(
         wpiunits_src_jar
-        BASE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/src/main/java
+        BASE_DIRECTORIES
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/main/java
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/generated/main/java
         OUTPUT_NAME wpiunits-sources
     )
     set_property(TARGET wpiunits_src_jar PROPERTY FOLDER "java")

wpiunits/build.gradle

@@ -12,3 +12,5 @@ apply from: "${rootDir}/shared/java/javacommon.gradle"
 
 dependencies {
 }
+
+sourceSets.main.java.srcDir "${projectDir}/src/generated/main/java"

wpiunits/generate_units.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+
+# Copyright (c) FIRST and other WPILib contributors.
+# Open Source Software; you can modify and/or share it under the terms of
+# the WPILib BSD license file in the root directory of this project.
+
+# This script generates unit-specific interfaces and mutable and immutable implementations of
+# those interfaces.
+# Generated files will be located in wpiunits/src/generated/main/
+
+import inspect
+import os
+import re
+from jinja2 import Environment, FileSystemLoader
+
+
+def output(outPath, outfn, contents):
+    if not os.path.exists(outPath):
+        os.makedirs(outPath)
+
+    outpathname = f"{outPath}/{outfn}"
+
+    if os.path.exists(outpathname):
+        with open(outpathname, "r") as f:
+            if f.read() == contents:
+                return
+
+    # File either doesn't exist or has different contents
+    with open(outpathname, "w", newline="\n") as f:
+        f.write(contents)
+
+
+# The units for which multiply and divide mathematical operations are defined
+MATH_OPERATION_UNITS = [
+    "Acceleration<?>",
+    "Angle",
+    "AngularAcceleration",
+    "AngularMomentum",
+    "AngularVelocity",
+    "Current",
+    "Dimensionless",
+    "Distance",
+    "Energy",
+    "Force",
+    "Frequency",
+    "LinearAcceleration",
+    "LinearMomentum",
+    "LinearVelocity",
+    "Mass",
+    "MomentOfInertia",
+    "Mult<?, ?>",
+    "Per<?, ?>",
+    "Power",
+    "Temperature",
+    "Time",
+    "Torque",
+    "Velocity<?>",
+    "Voltage",
+]
+
+# Configurations for all generated units
+UNIT_CONFIGURATIONS = {
+    "Acceleration": {
+        "base_unit": "unit()",
+        "generics": {"D": {"extends": "Unit"}},
+        "multiply": {},
+        "divide": {},
+    },
+    "Angle": {
+        "base_unit": "Radians",
+        "multiply": {"Frequency": "AngularVelocity"},
+        "divide": {"Time": "AngularVelocity"},
+    },
+    "AngularAcceleration": {
+        "base_unit": "RadiansPerSecondPerSecond",
+        "multiply": {"Time": "AngularVelocity"},
+        "divide": {"Frequency": "AngularVelocity"},
+    },
+    "AngularMomentum": {
+        "base_unit": "KilogramMetersSquaredPerSecond",
+        "multiply": {},
+        "divide": {"AngularVelocity": "MomentOfInertia"},
+    },
+    "AngularVelocity": {
+        "base_unit": "RadiansPerSecond",
+        "multiply": {"Time": "Angle", "Frequency": "AngularAcceleration"},
+        "divide": {"Time": "AngularAcceleration"},
+        "extra": inspect.cleandoc(
+            """
+          default Frequency asFrequency() { return Hertz.of(baseUnitMagnitude()); }
+        """
+        ),
+    },
+    "Current": {"base_unit": "Amps", "multiply": {"Voltage": "Power"}, "divide": {}},
+    "Dimensionless": {
+        "base_unit": "Value",
+        "multiply": {
+            "Angle": "Angle",
+            "AngularAcceleration": "AngularAcceleration",
+            "AngularMomentum": "AngularMomentum",
+            "AngularVelocity": "AngularVelocity",
+            "Current": "Current",
+            "Dimensionless": "Dimensionless",
+            "Distance": "Distance",
+            "Energy": "Energy",
+            "Force": "Force",
+            "Frequency": "Frequency",
+            "LinearAcceleration": "LinearAcceleration",
+            "LinearMomentum": "LinearMomentum",
+            "LinearVelocity": "LinearVelocity",
+            "Mass": "Mass",
+            "MomentOfInertia": "MomentOfInertia",
+            "Power": "Power",
+            "Temperature": "Temperature",
+            "Time": "Time",
+            "Torque": "Torque",
+            "Voltage": "Voltage",
+        },
+        "divide": {
+            "Time": "Frequency",
+            # TODO:
+            # "AngularVelocity": "Per<TimeUnit, AngleUnit>",
+            # "AngularAcceleration": "Per<TimeUnit, AngularVelocityUnit>",
+            # "LinearVelocity": "Per<TimeUnit, DistanceUnit>",
+            # "LinearAcceleration": "Per<TimeUnit, LinearVelocityUnit>",
+            # "Velocity<?>": "Per<TimeUnit, ?>",
+            # "Acceleration<?>": "Per<TimeUnit, VelocityUnit<?>>
+            # "Per<N, D>": "Per<D, N>"
+        },
+    },
+    "Distance": {
+        "base_unit": "Meters",
+        "multiply": {
+            "Frequency": "LinearVelocity",
+            # Distance x Force = Torque
+            # Force x Distance = Energy
+            "Force": "Torque",
+        },
+        "divide": {"Time": "LinearVelocity", "LinearVelocity": "Time"},
+    },
+    "Energy": {
+        "base_unit": "Joules",
+        "multiply": {"Frequency": "Power"},
+        "divide": {"Time": "Power"},
+    },
+    "Force": {
+        "base_unit": "Newtons",
+        "multiply": {
+            # Distance x Force = Torque
+            # Force x Distance = Energy
+            "Distance": "Energy"
+        },
+        "divide": {"Mass": "LinearAcceleration", "LinearAcceleration": "Mass"},
+    },
+    "Frequency": {
+        "base_unit": "Hertz",
+        "multiply": {
+            "Time": "Dimensionless",
+            "Distance": "LinearVelocity",
+            "LinearVelocity": "LinearAcceleration",
+            "Angle": "AngularVelocity",
+            "AngularVelocity": "AngularAcceleration",
+        },
+        "divide": {},
+        "extra": inspect.cleandoc(
+            """
+          /** Converts this frequency to the time period between cycles. */
+          default Time asPeriod() { return Seconds.of(1 / baseUnitMagnitude()); }
+        """
+        ),
+    },
+    "LinearAcceleration": {
+        "base_unit": "MetersPerSecondPerSecond",
+        "multiply": {"Time": "LinearVelocity"},
+        "divide": {"Frequency": "LinearVelocity"},
+    },
+    "LinearMomentum": {
+        "base_unit": "KilogramMetersPerSecond",
+        "multiply": {"Frequency": "Force"},
+        "divide": {"Mass": "LinearVelocity", "LinearVelocity": "Mass", "Time": "Force"},
+    },
+    "LinearVelocity": {
+        "base_unit": "MetersPerSecond",
+        "multiply": {"Time": "Distance", "Frequency": "LinearAcceleration"},
+        "divide": {"Time": "LinearAcceleration"},
+    },
+    "Mass": {
+        "base_unit": "Kilograms",
+        "multiply": {"LinearAcceleration": "Force"},
+        "divide": {},
+    },
+    "MomentOfInertia": {
+        "base_unit": "KilogramSquareMeters",
+        "multiply": {"AngularVelocity": "AngularMomentum"},
+        "divide": {},
+    },
+    "Mult": {
+        "base_unit": "unit()",
+        "generics": {"A": {"extends": "Unit"}, "B": {"extends": "Unit"}},
+        "multiply": {},
+        "divide": {},
+    },
+    "Per": {
+        "base_unit": "unit()",
+        "generics": {"Dividend": {"extends": "Unit"}, "Divisor": {"extends": "Unit"}},
+        "multiply": {},
+        "divide": {},
+        "extra": inspect.cleandoc(
+            """
+          default Measure<Dividend> timesDivisor(Measure<? extends Divisor> multiplier) {
+            return (Measure<Dividend>) baseUnit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+          }
+
+          default Measure<? extends PerUnit<Divisor, Dividend>> reciprocal() {
+            // May return a velocity if Divisor == TimeUnit, so we can't guarantee a "Per" instance
+            return baseUnit().reciprocal().ofBaseUnits(1 / baseUnitMagnitude());
+          }
+        """
+        ),
+    },
+    "Power": {
+        "base_unit": "Watts",
+        "multiply": {
+            "Time": "Energy",
+        },
+        "divide": {"Voltage": "Current", "Current": "Voltage", "Energy": "Frequency"},
+    },
+    "Temperature": {"base_unit": "Kelvin", "multiply": {}, "divide": {}},
+    "Time": {
+        "base_unit": "Seconds",
+        "multiply": {
+            "Frequency": "Dimensionless",
+            "AngularVelocity": "Angle",
+            "AngularAcceleration": "AngularVelocity",
+            "LinearVelocity": "Distance",
+            "LinearAcceleration": "LinearVelocity",
+            # TODO:
+            # "Acceleration<D>": "Velocity<D>"
+            # "Velocity<D>": "Measure<D>"
+        },
+        "divide": {
+            # Time specifically needs this to be called out so generated methods like
+            # `per(TimeUnit)` or `divide(Time)` will return dimensionless values instead of
+            # `Velocity<TimeUnit>` (i.e. a time per unit time ratio)
+            "Time": "Dimensionless"
+        },
+        "extra": inspect.cleandoc(
+            """
+          default Frequency asFrequency() { return Hertz.of(1 / baseUnitMagnitude()); }
+        """
+        ),
+    },
+    "Torque": {
+        "base_unit": "NewtonMeters",
+        "multiply": {},
+        "divide": {"Distance": "Force", "Force": "Distance"},
+    },
+    "Velocity": {
+        "base_unit": "unit()",
+        "generics": {"D": {"extends": "Unit"}},
+        "multiply": {},
+        "divide": {},
+    },
+    "Voltage": {"base_unit": "Volts", "multiply": {"Current": "Power"}, "divide": {}},
+}
+
+
+def generics_list(measure_name):
+    if "generics" in UNIT_CONFIGURATIONS[measure_name]:
+        args = []
+        for name, config in UNIT_CONFIGURATIONS[measure_name]["generics"].items():
+            if "extends" in config:
+                args.append("{} extends {}".format(name, config["extends"]))
+            elif "super" in config:
+                args.append("{} super {}".format(name, config["super"]))
+            else:
+                args.append(name)
+
+        return "<{}>".format(", ".join(args))
+    else:
+        return ""
+
+
+def generics_usage(measure_name):
+    if "generics" in UNIT_CONFIGURATIONS[measure_name]:
+        args = UNIT_CONFIGURATIONS[measure_name]["generics"].keys()
+
+        return "<{}>".format(", ".join(args))
+    else:
+        return ""
+
+
+def type_decl(measure_name):
+    return measure_name + generics_list(measure_name)
+
+
+def type_usage(measure_name):
+    return measure_name + generics_usage(measure_name)
+
+
+# measure-to-unit
+def mtou(measure_name):
+    if (
+        measure_name in UNIT_CONFIGURATIONS
+        and "generics" in UNIT_CONFIGURATIONS[measure_name]
+    ):
+        return "{}Unit{}".format(measure_name, generics_usage(measure_name))
+    else:
+        regex = re.compile(r"^(.*?)(<.*>)?$")
+        return re.sub(regex, "\\1Unit\\2", measure_name)
+
+
+def main():
+
+    dirname, _ = os.path.split(os.path.abspath(__file__))
+
+    env = Environment(
+        loader=FileSystemLoader(f"{dirname}/src/generate/main/java"),
+        autoescape=False,
+        keep_trailing_newline=True,
+    )
+
+    interfaceTemplate = env.get_template("Measure-interface.java.jinja")
+    immutableTemplate = env.get_template("Measure-immutable.java.jinja")
+    mutableTemplate = env.get_template("Measure-mutable.java.jinja")
+    rootPath = f"{dirname}/src/generated/main/java/edu/wpi/first/units"
+
+    helpers = {
+        "type_decl": type_decl,
+        "type_usage": type_usage,
+        "generics_list": generics_list,
+        "generics_usage": generics_usage,
+        "mtou": mtou,
+    }
+
+    for unit_name in UNIT_CONFIGURATIONS:
+        interfaceContents = interfaceTemplate.render(
+            name=unit_name,
+            math_units=MATH_OPERATION_UNITS,
+            config=UNIT_CONFIGURATIONS,
+            helpers=helpers,
+        )
+        immutableContents = immutableTemplate.render(
+            name=unit_name,
+            units=MATH_OPERATION_UNITS,
+            config=UNIT_CONFIGURATIONS,
+            helpers=helpers,
+        )
+        mutableContents = mutableTemplate.render(
+            name=unit_name,
+            units=MATH_OPERATION_UNITS,
+            config=UNIT_CONFIGURATIONS,
+            helpers=helpers,
+        )
+
+        output(f"{rootPath}/measure", f"{unit_name}.java", interfaceContents)
+        output(f"{rootPath}/measure", f"Immutable{unit_name}.java", immutableContents)
+        output(f"{rootPath}/measure", f"Mut{unit_name}.java", mutableContents)
+
+
+if __name__ == "__main__":
+    main()

wpiunits/src/generate/main/java/Measure-immutable.java.jinja

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record Immutable{{ helpers['type_decl'](name) }}(double magnitude, double baseUnitMagnitude, {{ helpers['mtou'](name) }} unit) implements {{ helpers['type_usage'](name) }} {
+  @Override
+  public {{ helpers['type_usage'](name) }} copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generate/main/java/Measure-interface.java.jinja

@@ -0,0 +1,117 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mtou'](name) }}> {
+  static {{ helpers['generics_list'](name) }} {{ helpers['type_usage'](name) }} ofRelativeUnits(double magnitude, {{ helpers['mtou'](name) }} unit) {
+    return new Immutable{{ helpers['type_usage'](name) }}(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static {{ helpers['generics_list'](name) }} {{ helpers['type_usage'](name) }} ofBaseUnits(double baseUnitMagnitude, {{ helpers['mtou'](name) }} unit) {
+    return new Immutable{{ helpers['type_usage'](name) }}(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  {{ helpers['type_usage'](name) }} copy();
+
+  @Override
+  default Mut{{ helpers['type_usage'](name) }} mutableCopy() {
+    return new Mut{{ helpers['type_usage'](name) }}(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  {{ helpers['mtou'](name) }} unit();
+
+  @Override
+  default {{ helpers['mtou'](name) }} baseUnit() { return ({{ helpers['mtou'](name) }}) unit().getBaseUnit(); }
+
+  @Override
+  default double in({{ helpers['mtou'](name) }} unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default {{ helpers['type_usage'](name) }} unaryMinus() {
+    return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default {{ helpers['type_usage'](name) }} plus(Measure<? extends {{ helpers['mtou'](name) }}> other) {
+    return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default {{ helpers['type_usage'](name) }} minus(Measure<? extends {{ helpers['mtou'](name) }}> other) {
+    return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default {{ helpers['type_usage'](name) }} times(double multiplier) {
+    return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default {{ helpers['type_usage'](name) }} divide(double divisor) {
+    return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default {{ config[name]['divide']['Time'] or "Velocity<{}>".format(helpers['mtou'](name)) }} per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+{% for unit in math_units -%}
+{% if unit == "Dimensionless" %}
+  @Override
+  default {{ helpers['type_usage'](name) }} divide({{ unit }} divisor) {
+    return ({{ helpers['type_usage'](name) }}) {{ config[name]['base_unit'] }}.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default {{ helpers['type_usage'](name) }} times({{ unit }} multiplier) {
+    return ({{ helpers['type_usage'](name) }}) {{ config[name]['base_unit'] }}.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+{% else %}
+{% if unit in config[name]['multiply'] %}
+  @Override
+  default {{ config[name]['multiply'][unit] }} times({{ unit }} multiplier) {
+    return {{ config[config[name]['multiply'][unit]]['base_unit'] }}.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+{% else %}
+  @Override
+  default Mult<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> times({{ unit }} multiplier) {
+    return (Mult<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}>) Measure.super.times(multiplier);
+  }
+{% endif -%}
+{% if unit in config[name]['divide'] %}
+  @Override
+  default {{ config[name]['divide'][unit] }} divide({{ unit }} divisor) {
+    return {{ config[config[name]['divide'][unit]]['base_unit'] }}.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+{% elif unit == "Time" %}
+  @Override
+  default Velocity<{{ helpers['mtou'](name) }}> divide({{ unit }} divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+{% elif unit == name %}
+  @Override
+  default Dimensionless divide({{ unit }} divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+{% else %}
+  @Override
+  default Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> divide({{ unit }} divisor) {
+    return (Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}>) Measure.super.divide(divisor);
+  }
+{% endif -%}
+{% endif -%}
+{% endfor -%}
+{{ config[name]['extra'] }}
+}

wpiunits/src/generate/main/java/Measure-mutable.java.jinja

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class Mut{{ helpers['type_decl'](name) }}
+  extends MutableMeasureBase<{{ helpers['mtou'](name) }}, {{ helpers['type_usage'](name) }}, Mut{{ helpers['type_usage'](name) }}>
+  implements {{ helpers['type_usage'](name) }} {
+  public Mut{{ name }}(double magnitude, double baseUnitMagnitude, {{ helpers['mtou'](name) }} unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public {{ helpers['type_usage'](name) }} copy() {
+    return new Immutable{{ helpers['type_usage'](name) }}(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D>> {
+  static <D extends Unit> Acceleration<D> ofRelativeUnits(double magnitude, AccelerationUnit<D> unit) {
+    return new ImmutableAcceleration<D>(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static <D extends Unit> Acceleration<D> ofBaseUnits(double baseUnitMagnitude, AccelerationUnit<D> unit) {
+    return new ImmutableAcceleration<D>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Acceleration<D> copy();
+
+  @Override
+  default MutAcceleration<D> mutableCopy() {
+    return new MutAcceleration<D>(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  AccelerationUnit<D> unit();
+
+  @Override
+  default AccelerationUnit<D> baseUnit() { return (AccelerationUnit<D>) unit().getBaseUnit(); }
+
+  @Override
+  default double in(AccelerationUnit<D> unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Acceleration<D> unaryMinus() {
+    return (Acceleration<D>) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Acceleration<D> plus(Measure<? extends AccelerationUnit<D>> other) {
+    return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Acceleration<D> minus(Measure<? extends AccelerationUnit<D>> other) {
+    return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Acceleration<D> times(double multiplier) {
+    return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Acceleration<D> divide(double divisor) {
+    return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<AccelerationUnit<D>> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<AccelerationUnit<D>, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<AccelerationUnit<D>, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, AngleUnit> times(Angle multiplier) {
+    return (Mult<AccelerationUnit<D>, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, AngleUnit> divide(Angle divisor) {
+    return (Per<AccelerationUnit<D>, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<AccelerationUnit<D>, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<AccelerationUnit<D>, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<AccelerationUnit<D>, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<AccelerationUnit<D>, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<AccelerationUnit<D>, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<AccelerationUnit<D>, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, CurrentUnit> times(Current multiplier) {
+    return (Mult<AccelerationUnit<D>, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, CurrentUnit> divide(Current divisor) {
+    return (Per<AccelerationUnit<D>, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Acceleration<D> divide(Dimensionless divisor) {
+    return (Acceleration<D>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Acceleration<D> times(Dimensionless multiplier) {
+    return (Acceleration<D>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, DistanceUnit> times(Distance multiplier) {
+    return (Mult<AccelerationUnit<D>, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, DistanceUnit> divide(Distance divisor) {
+    return (Per<AccelerationUnit<D>, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, EnergyUnit> times(Energy multiplier) {
+    return (Mult<AccelerationUnit<D>, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, EnergyUnit> divide(Energy divisor) {
+    return (Per<AccelerationUnit<D>, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, ForceUnit> times(Force multiplier) {
+    return (Mult<AccelerationUnit<D>, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, ForceUnit> divide(Force divisor) {
+    return (Per<AccelerationUnit<D>, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<AccelerationUnit<D>, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<AccelerationUnit<D>, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<AccelerationUnit<D>, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<AccelerationUnit<D>, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<AccelerationUnit<D>, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<AccelerationUnit<D>, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<AccelerationUnit<D>, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<AccelerationUnit<D>, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, MassUnit> times(Mass multiplier) {
+    return (Mult<AccelerationUnit<D>, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, MassUnit> divide(Mass divisor) {
+    return (Per<AccelerationUnit<D>, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<AccelerationUnit<D>, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<AccelerationUnit<D>, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<AccelerationUnit<D>, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<AccelerationUnit<D>, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<AccelerationUnit<D>, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<AccelerationUnit<D>, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, PowerUnit> times(Power multiplier) {
+    return (Mult<AccelerationUnit<D>, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, PowerUnit> divide(Power divisor) {
+    return (Per<AccelerationUnit<D>, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<AccelerationUnit<D>, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<AccelerationUnit<D>, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, TimeUnit> times(Time multiplier) {
+    return (Mult<AccelerationUnit<D>, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<AccelerationUnit<D>> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, TorqueUnit> times(Torque multiplier) {
+    return (Mult<AccelerationUnit<D>, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, TorqueUnit> divide(Torque divisor) {
+    return (Per<AccelerationUnit<D>, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<AccelerationUnit<D>, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<AccelerationUnit<D>, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<AccelerationUnit<D>, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, VoltageUnit> divide(Voltage divisor) {
+    return (Per<AccelerationUnit<D>, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Angle extends Measure<AngleUnit> {
+  static  Angle ofRelativeUnits(double magnitude, AngleUnit unit) {
+    return new ImmutableAngle(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Angle ofBaseUnits(double baseUnitMagnitude, AngleUnit unit) {
+    return new ImmutableAngle(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Angle copy();
+
+  @Override
+  default MutAngle mutableCopy() {
+    return new MutAngle(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  AngleUnit unit();
+
+  @Override
+  default AngleUnit baseUnit() { return (AngleUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(AngleUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Angle unaryMinus() {
+    return (Angle) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Angle plus(Measure<? extends AngleUnit> other) {
+    return (Angle) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Angle minus(Measure<? extends AngleUnit> other) {
+    return (Angle) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Angle times(double multiplier) {
+    return (Angle) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Angle divide(double divisor) {
+    return (Angle) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default AngularVelocity per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<AngleUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<AngleUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<AngleUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<AngleUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Angle divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngleUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<AngleUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<AngleUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<AngleUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<AngleUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<AngleUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<AngleUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<AngleUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<AngleUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Angle divide(Dimensionless divisor) {
+    return (Angle) Radians.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Angle times(Dimensionless multiplier) {
+    return (Angle) Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngleUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<AngleUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<AngleUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<AngleUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<AngleUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<AngleUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, ForceUnit> divide(Force divisor) {
+    return (Per<AngleUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularVelocity times(Frequency multiplier) {
+    return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<AngleUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<AngleUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<AngleUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<AngleUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<AngleUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<AngleUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<AngleUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<AngleUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<AngleUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, MassUnit> divide(Mass divisor) {
+    return (Per<AngleUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<AngleUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<AngleUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<AngleUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<AngleUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<AngleUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<AngleUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<AngleUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, PowerUnit> divide(Power divisor) {
+    return (Per<AngleUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<AngleUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<AngleUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<AngleUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default AngularVelocity divide(Time divisor) {
+    return RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngleUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<AngleUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<AngleUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<AngleUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<AngleUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<AngleUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<AngleUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
+  static  AngularAcceleration ofRelativeUnits(double magnitude, AngularAccelerationUnit unit) {
+    return new ImmutableAngularAcceleration(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  AngularAcceleration ofBaseUnits(double baseUnitMagnitude, AngularAccelerationUnit unit) {
+    return new ImmutableAngularAcceleration(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  AngularAcceleration copy();
+
+  @Override
+  default MutAngularAcceleration mutableCopy() {
+    return new MutAngularAcceleration(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  AngularAccelerationUnit unit();
+
+  @Override
+  default AngularAccelerationUnit baseUnit() { return (AngularAccelerationUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(AngularAccelerationUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration unaryMinus() {
+    return (AngularAcceleration) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration plus(Measure<? extends AngularAccelerationUnit> other) {
+    return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration minus(Measure<? extends AngularAccelerationUnit> other) {
+    return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration times(double multiplier) {
+    return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default AngularAcceleration divide(double divisor) {
+    return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<AngularAccelerationUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<AngularAccelerationUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<AngularAccelerationUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<AngularAccelerationUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<AngularAccelerationUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<AngularAccelerationUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(AngularAcceleration divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<AngularAccelerationUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<AngularAccelerationUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<AngularAccelerationUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<AngularAccelerationUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<AngularAccelerationUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<AngularAccelerationUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default AngularAcceleration divide(Dimensionless divisor) {
+    return (AngularAcceleration) RadiansPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration times(Dimensionless multiplier) {
+    return (AngularAcceleration) RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<AngularAccelerationUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<AngularAccelerationUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<AngularAccelerationUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<AngularAccelerationUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<AngularAccelerationUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, ForceUnit> divide(Force divisor) {
+    return (Per<AngularAccelerationUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<AngularAccelerationUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default AngularVelocity divide(Frequency divisor) {
+    return RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<AngularAccelerationUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<AngularAccelerationUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<AngularAccelerationUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<AngularAccelerationUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<AngularAccelerationUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<AngularAccelerationUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<AngularAccelerationUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, MassUnit> divide(Mass divisor) {
+    return (Per<AngularAccelerationUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<AngularAccelerationUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<AngularAccelerationUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<AngularAccelerationUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<AngularAccelerationUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<AngularAccelerationUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<AngularAccelerationUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<AngularAccelerationUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, PowerUnit> divide(Power divisor) {
+    return (Per<AngularAccelerationUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<AngularAccelerationUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<AngularAccelerationUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularVelocity times(Time multiplier) {
+    return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<AngularAccelerationUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<AngularAccelerationUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<AngularAccelerationUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<AngularAccelerationUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<AngularAccelerationUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<AngularAccelerationUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<AngularAccelerationUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface AngularMomentum extends Measure<AngularMomentumUnit> {
+  static  AngularMomentum ofRelativeUnits(double magnitude, AngularMomentumUnit unit) {
+    return new ImmutableAngularMomentum(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  AngularMomentum ofBaseUnits(double baseUnitMagnitude, AngularMomentumUnit unit) {
+    return new ImmutableAngularMomentum(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  AngularMomentum copy();
+
+  @Override
+  default MutAngularMomentum mutableCopy() {
+    return new MutAngularMomentum(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  AngularMomentumUnit unit();
+
+  @Override
+  default AngularMomentumUnit baseUnit() { return (AngularMomentumUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(AngularMomentumUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularMomentum unaryMinus() {
+    return (AngularMomentum) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularMomentum plus(Measure<? extends AngularMomentumUnit> other) {
+    return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularMomentum minus(Measure<? extends AngularMomentumUnit> other) {
+    return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularMomentum times(double multiplier) {
+    return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default AngularMomentum divide(double divisor) {
+    return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<AngularMomentumUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<AngularMomentumUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<AngularMomentumUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<AngularMomentumUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<AngularMomentumUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<AngularMomentumUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<AngularMomentumUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<AngularMomentumUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(AngularMomentum divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<AngularMomentumUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default MomentOfInertia divide(AngularVelocity divisor) {
+    return KilogramSquareMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<AngularMomentumUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<AngularMomentumUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default AngularMomentum divide(Dimensionless divisor) {
+    return (AngularMomentum) KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularMomentum times(Dimensionless multiplier) {
+    return (AngularMomentum) KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<AngularMomentumUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<AngularMomentumUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<AngularMomentumUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<AngularMomentumUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<AngularMomentumUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, ForceUnit> divide(Force divisor) {
+    return (Per<AngularMomentumUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<AngularMomentumUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<AngularMomentumUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<AngularMomentumUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<AngularMomentumUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<AngularMomentumUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<AngularMomentumUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<AngularMomentumUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<AngularMomentumUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<AngularMomentumUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, MassUnit> divide(Mass divisor) {
+    return (Per<AngularMomentumUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<AngularMomentumUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<AngularMomentumUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<AngularMomentumUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<AngularMomentumUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<AngularMomentumUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<AngularMomentumUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<AngularMomentumUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, PowerUnit> divide(Power divisor) {
+    return (Per<AngularMomentumUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<AngularMomentumUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<AngularMomentumUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<AngularMomentumUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<AngularMomentumUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<AngularMomentumUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<AngularMomentumUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<AngularMomentumUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<AngularMomentumUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<AngularMomentumUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<AngularMomentumUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface AngularVelocity extends Measure<AngularVelocityUnit> {
+  static  AngularVelocity ofRelativeUnits(double magnitude, AngularVelocityUnit unit) {
+    return new ImmutableAngularVelocity(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  AngularVelocity ofBaseUnits(double baseUnitMagnitude, AngularVelocityUnit unit) {
+    return new ImmutableAngularVelocity(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  AngularVelocity copy();
+
+  @Override
+  default MutAngularVelocity mutableCopy() {
+    return new MutAngularVelocity(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  AngularVelocityUnit unit();
+
+  @Override
+  default AngularVelocityUnit baseUnit() { return (AngularVelocityUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(AngularVelocityUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularVelocity unaryMinus() {
+    return (AngularVelocity) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularVelocity plus(Measure<? extends AngularVelocityUnit> other) {
+    return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularVelocity minus(Measure<? extends AngularVelocityUnit> other) {
+    return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularVelocity times(double multiplier) {
+    return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default AngularVelocity divide(double divisor) {
+    return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default AngularAcceleration per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<AngularVelocityUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<AngularVelocityUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<AngularVelocityUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<AngularVelocityUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<AngularVelocityUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<AngularVelocityUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<AngularVelocityUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<AngularVelocityUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<AngularVelocityUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(AngularVelocity divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<AngularVelocityUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<AngularVelocityUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default AngularVelocity divide(Dimensionless divisor) {
+    return (AngularVelocity) RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularVelocity times(Dimensionless multiplier) {
+    return (AngularVelocity) RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<AngularVelocityUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<AngularVelocityUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<AngularVelocityUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<AngularVelocityUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<AngularVelocityUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, ForceUnit> divide(Force divisor) {
+    return (Per<AngularVelocityUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularAcceleration times(Frequency multiplier) {
+    return RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<AngularVelocityUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<AngularVelocityUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<AngularVelocityUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<AngularVelocityUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<AngularVelocityUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<AngularVelocityUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<AngularVelocityUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<AngularVelocityUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, MassUnit> divide(Mass divisor) {
+    return (Per<AngularVelocityUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<AngularVelocityUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<AngularVelocityUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<AngularVelocityUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<AngularVelocityUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<AngularVelocityUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<AngularVelocityUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<AngularVelocityUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, PowerUnit> divide(Power divisor) {
+    return (Per<AngularVelocityUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<AngularVelocityUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<AngularVelocityUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Angle times(Time multiplier) {
+    return Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration divide(Time divisor) {
+    return RadiansPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<AngularVelocityUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<AngularVelocityUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<AngularVelocityUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<AngularVelocityUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<AngularVelocityUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<AngularVelocityUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+default Frequency asFrequency() { return Hertz.of(baseUnitMagnitude()); }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Current extends Measure<CurrentUnit> {
+  static  Current ofRelativeUnits(double magnitude, CurrentUnit unit) {
+    return new ImmutableCurrent(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Current ofBaseUnits(double baseUnitMagnitude, CurrentUnit unit) {
+    return new ImmutableCurrent(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Current copy();
+
+  @Override
+  default MutCurrent mutableCopy() {
+    return new MutCurrent(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  CurrentUnit unit();
+
+  @Override
+  default CurrentUnit baseUnit() { return (CurrentUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(CurrentUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Current unaryMinus() {
+    return (Current) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Current plus(Measure<? extends CurrentUnit> other) {
+    return (Current) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Current minus(Measure<? extends CurrentUnit> other) {
+    return (Current) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Current times(double multiplier) {
+    return (Current) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Current divide(double divisor) {
+    return (Current) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<CurrentUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<CurrentUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<CurrentUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<CurrentUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<CurrentUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<CurrentUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<CurrentUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<CurrentUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<CurrentUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<CurrentUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<CurrentUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<CurrentUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Current divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Current divide(Dimensionless divisor) {
+    return (Current) Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Current times(Dimensionless multiplier) {
+    return (Current) Amps.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<CurrentUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<CurrentUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<CurrentUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<CurrentUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<CurrentUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, ForceUnit> divide(Force divisor) {
+    return (Per<CurrentUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<CurrentUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<CurrentUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<CurrentUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<CurrentUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<CurrentUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<CurrentUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<CurrentUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<CurrentUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<CurrentUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, MassUnit> divide(Mass divisor) {
+    return (Per<CurrentUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<CurrentUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<CurrentUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<CurrentUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<CurrentUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<CurrentUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<CurrentUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<CurrentUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, PowerUnit> divide(Power divisor) {
+    return (Per<CurrentUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<CurrentUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<CurrentUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<CurrentUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<CurrentUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<CurrentUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<CurrentUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<CurrentUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<CurrentUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Power times(Voltage multiplier) {
+    return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<CurrentUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<CurrentUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Dimensionless extends Measure<DimensionlessUnit> {
+  static  Dimensionless ofRelativeUnits(double magnitude, DimensionlessUnit unit) {
+    return new ImmutableDimensionless(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Dimensionless ofBaseUnits(double baseUnitMagnitude, DimensionlessUnit unit) {
+    return new ImmutableDimensionless(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Dimensionless copy();
+
+  @Override
+  default MutDimensionless mutableCopy() {
+    return new MutDimensionless(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  DimensionlessUnit unit();
+
+  @Override
+  default DimensionlessUnit baseUnit() { return (DimensionlessUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(DimensionlessUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Dimensionless unaryMinus() {
+    return (Dimensionless) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Dimensionless plus(Measure<? extends DimensionlessUnit> other) {
+    return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Dimensionless minus(Measure<? extends DimensionlessUnit> other) {
+    return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Dimensionless times(double multiplier) {
+    return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(double divisor) {
+    return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Frequency per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<DimensionlessUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<DimensionlessUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DimensionlessUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<DimensionlessUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Angle times(Angle multiplier) {
+    return Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<DimensionlessUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularAcceleration times(AngularAcceleration multiplier) {
+    return RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<DimensionlessUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularMomentum times(AngularMomentum multiplier) {
+    return KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<DimensionlessUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularVelocity times(AngularVelocity multiplier) {
+    return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<DimensionlessUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Current times(Current multiplier) {
+    return Amps.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<DimensionlessUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Dimensionless divide(Dimensionless divisor) {
+    return (Dimensionless) Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Dimensionless times(Dimensionless multiplier) {
+    return (Dimensionless) Value.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Distance times(Distance multiplier) {
+    return Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<DimensionlessUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Energy times(Energy multiplier) {
+    return Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<DimensionlessUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Force times(Force multiplier) {
+    return Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, ForceUnit> divide(Force divisor) {
+    return (Per<DimensionlessUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Frequency times(Frequency multiplier) {
+    return Hertz.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<DimensionlessUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearAcceleration times(LinearAcceleration multiplier) {
+    return MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<DimensionlessUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearMomentum times(LinearMomentum multiplier) {
+    return KilogramMetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<DimensionlessUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearVelocity times(LinearVelocity multiplier) {
+    return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<DimensionlessUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mass times(Mass multiplier) {
+    return Kilograms.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, MassUnit> divide(Mass divisor) {
+    return (Per<DimensionlessUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default MomentOfInertia times(MomentOfInertia multiplier) {
+    return KilogramSquareMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<DimensionlessUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DimensionlessUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<DimensionlessUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DimensionlessUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<DimensionlessUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DimensionlessUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<DimensionlessUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DimensionlessUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<DimensionlessUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Power times(Power multiplier) {
+    return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, PowerUnit> divide(Power divisor) {
+    return (Per<DimensionlessUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Temperature times(Temperature multiplier) {
+    return Kelvin.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<DimensionlessUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Time times(Time multiplier) {
+    return Seconds.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency divide(Time divisor) {
+    return Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Torque times(Torque multiplier) {
+    return NewtonMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<DimensionlessUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DimensionlessUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<DimensionlessUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DimensionlessUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<DimensionlessUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Voltage times(Voltage multiplier) {
+    return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<DimensionlessUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Distance extends Measure<DistanceUnit> {
+  static  Distance ofRelativeUnits(double magnitude, DistanceUnit unit) {
+    return new ImmutableDistance(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Distance ofBaseUnits(double baseUnitMagnitude, DistanceUnit unit) {
+    return new ImmutableDistance(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Distance copy();
+
+  @Override
+  default MutDistance mutableCopy() {
+    return new MutDistance(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  DistanceUnit unit();
+
+  @Override
+  default DistanceUnit baseUnit() { return (DistanceUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(DistanceUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Distance unaryMinus() {
+    return (Distance) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Distance plus(Measure<? extends DistanceUnit> other) {
+    return (Distance) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Distance minus(Measure<? extends DistanceUnit> other) {
+    return (Distance) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Distance times(double multiplier) {
+    return (Distance) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Distance divide(double divisor) {
+    return (Distance) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default LinearVelocity per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<DistanceUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<DistanceUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<DistanceUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<DistanceUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<DistanceUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<DistanceUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<DistanceUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<DistanceUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<DistanceUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<DistanceUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<DistanceUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<DistanceUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Distance divide(Dimensionless divisor) {
+    return (Distance) Meters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Distance times(Dimensionless multiplier) {
+    return (Distance) Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<DistanceUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Distance divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<DistanceUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<DistanceUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Torque times(Force multiplier) {
+    return NewtonMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DistanceUnit, ForceUnit> divide(Force divisor) {
+    return (Per<DistanceUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearVelocity times(Frequency multiplier) {
+    return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DistanceUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<DistanceUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<DistanceUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<DistanceUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<DistanceUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<DistanceUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<DistanceUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Time divide(LinearVelocity divisor) {
+    return Seconds.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<DistanceUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, MassUnit> divide(Mass divisor) {
+    return (Per<DistanceUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<DistanceUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<DistanceUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<DistanceUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<DistanceUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<DistanceUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<DistanceUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<DistanceUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, PowerUnit> divide(Power divisor) {
+    return (Per<DistanceUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<DistanceUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<DistanceUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<DistanceUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default LinearVelocity divide(Time divisor) {
+    return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<DistanceUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<DistanceUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<DistanceUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<DistanceUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<DistanceUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<DistanceUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Energy extends Measure<EnergyUnit> {
+  static  Energy ofRelativeUnits(double magnitude, EnergyUnit unit) {
+    return new ImmutableEnergy(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Energy ofBaseUnits(double baseUnitMagnitude, EnergyUnit unit) {
+    return new ImmutableEnergy(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Energy copy();
+
+  @Override
+  default MutEnergy mutableCopy() {
+    return new MutEnergy(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  EnergyUnit unit();
+
+  @Override
+  default EnergyUnit baseUnit() { return (EnergyUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(EnergyUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Energy unaryMinus() {
+    return (Energy) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Energy plus(Measure<? extends EnergyUnit> other) {
+    return (Energy) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Energy minus(Measure<? extends EnergyUnit> other) {
+    return (Energy) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Energy times(double multiplier) {
+    return (Energy) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Energy divide(double divisor) {
+    return (Energy) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Power per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<EnergyUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<EnergyUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<EnergyUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<EnergyUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<EnergyUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<EnergyUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<EnergyUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<EnergyUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<EnergyUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<EnergyUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<EnergyUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<EnergyUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Energy divide(Dimensionless divisor) {
+    return (Energy) Joules.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Energy times(Dimensionless multiplier) {
+    return (Energy) Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<EnergyUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<EnergyUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<EnergyUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Energy divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<EnergyUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, ForceUnit> divide(Force divisor) {
+    return (Per<EnergyUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Power times(Frequency multiplier) {
+    return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<EnergyUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<EnergyUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<EnergyUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<EnergyUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<EnergyUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<EnergyUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<EnergyUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<EnergyUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<EnergyUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, MassUnit> divide(Mass divisor) {
+    return (Per<EnergyUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<EnergyUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<EnergyUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<EnergyUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<EnergyUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<EnergyUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<EnergyUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<EnergyUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, PowerUnit> divide(Power divisor) {
+    return (Per<EnergyUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<EnergyUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<EnergyUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<EnergyUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Power divide(Time divisor) {
+    return Watts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<EnergyUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<EnergyUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<EnergyUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<EnergyUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<EnergyUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<EnergyUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Force extends Measure<ForceUnit> {
+  static  Force ofRelativeUnits(double magnitude, ForceUnit unit) {
+    return new ImmutableForce(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Force ofBaseUnits(double baseUnitMagnitude, ForceUnit unit) {
+    return new ImmutableForce(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Force copy();
+
+  @Override
+  default MutForce mutableCopy() {
+    return new MutForce(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  ForceUnit unit();
+
+  @Override
+  default ForceUnit baseUnit() { return (ForceUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(ForceUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Force unaryMinus() {
+    return (Force) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Force plus(Measure<? extends ForceUnit> other) {
+    return (Force) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Force minus(Measure<? extends ForceUnit> other) {
+    return (Force) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Force times(double multiplier) {
+    return (Force) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Force divide(double divisor) {
+    return (Force) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<ForceUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<ForceUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<ForceUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<ForceUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<ForceUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<ForceUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<ForceUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<ForceUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<ForceUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<ForceUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<ForceUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<ForceUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<ForceUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<ForceUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Force divide(Dimensionless divisor) {
+    return (Force) Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Force times(Dimensionless multiplier) {
+    return (Force) Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Energy times(Distance multiplier) {
+    return Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<ForceUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<ForceUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<ForceUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<ForceUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<ForceUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Force divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<ForceUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<ForceUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<ForceUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<ForceUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Mass divide(LinearAcceleration divisor) {
+    return Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<ForceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<ForceUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<ForceUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<ForceUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<ForceUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<ForceUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default LinearAcceleration divide(Mass divisor) {
+    return MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<ForceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<ForceUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<ForceUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<ForceUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<ForceUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<ForceUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<ForceUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<ForceUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, PowerUnit> divide(Power divisor) {
+    return (Per<ForceUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<ForceUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<ForceUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<ForceUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<ForceUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<ForceUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<ForceUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<ForceUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<ForceUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<ForceUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<ForceUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<ForceUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java

@@ -0,0 +1,335 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Frequency extends Measure<FrequencyUnit> {
+  static  Frequency ofRelativeUnits(double magnitude, FrequencyUnit unit) {
+    return new ImmutableFrequency(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Frequency ofBaseUnits(double baseUnitMagnitude, FrequencyUnit unit) {
+    return new ImmutableFrequency(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Frequency copy();
+
+  @Override
+  default MutFrequency mutableCopy() {
+    return new MutFrequency(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  FrequencyUnit unit();
+
+  @Override
+  default FrequencyUnit baseUnit() { return (FrequencyUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(FrequencyUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency unaryMinus() {
+    return (Frequency) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency plus(Measure<? extends FrequencyUnit> other) {
+    return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency minus(Measure<? extends FrequencyUnit> other) {
+    return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency times(double multiplier) {
+    return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Frequency divide(double divisor) {
+    return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<FrequencyUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<FrequencyUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<FrequencyUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularVelocity times(Angle multiplier) {
+    return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<FrequencyUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<FrequencyUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<FrequencyUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<FrequencyUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<FrequencyUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<FrequencyUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularAcceleration times(AngularVelocity multiplier) {
+    return RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<FrequencyUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<FrequencyUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<FrequencyUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<FrequencyUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Frequency divide(Dimensionless divisor) {
+    return (Frequency) Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency times(Dimensionless multiplier) {
+    return (Frequency) Hertz.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default LinearVelocity times(Distance multiplier) {
+    return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<FrequencyUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<FrequencyUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<FrequencyUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<FrequencyUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<FrequencyUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, ForceUnit> divide(Force divisor) {
+    return (Per<FrequencyUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<FrequencyUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Frequency divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<FrequencyUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<FrequencyUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<FrequencyUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<FrequencyUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearAcceleration times(LinearVelocity multiplier) {
+    return MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<FrequencyUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<FrequencyUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<FrequencyUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, MassUnit> divide(Mass divisor) {
+    return (Per<FrequencyUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<FrequencyUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<FrequencyUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<FrequencyUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<FrequencyUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<FrequencyUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<FrequencyUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<FrequencyUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, PowerUnit> divide(Power divisor) {
+    return (Per<FrequencyUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<FrequencyUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<FrequencyUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Dimensionless times(Time multiplier) {
+    return Value.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<FrequencyUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<FrequencyUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<FrequencyUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<FrequencyUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<FrequencyUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<FrequencyUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<FrequencyUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+/** Converts this frequency to the time period between cycles. */
+default Time asPeriod() { return Seconds.of(1 / baseUnitMagnitude()); }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAcceleration.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableAcceleration<D extends Unit>(double magnitude, double baseUnitMagnitude, AccelerationUnit<D> unit) implements Acceleration<D> {
+  @Override
+  public Acceleration<D> copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngle.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableAngle(double magnitude, double baseUnitMagnitude, AngleUnit unit) implements Angle {
+  @Override
+  public Angle copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularAcceleration.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableAngularAcceleration(double magnitude, double baseUnitMagnitude, AngularAccelerationUnit unit) implements AngularAcceleration {
+  @Override
+  public AngularAcceleration copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularMomentum.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableAngularMomentum(double magnitude, double baseUnitMagnitude, AngularMomentumUnit unit) implements AngularMomentum {
+  @Override
+  public AngularMomentum copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularVelocity.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableAngularVelocity(double magnitude, double baseUnitMagnitude, AngularVelocityUnit unit) implements AngularVelocity {
+  @Override
+  public AngularVelocity copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableCurrent.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableCurrent(double magnitude, double baseUnitMagnitude, CurrentUnit unit) implements Current {
+  @Override
+  public Current copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDimensionless.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableDimensionless(double magnitude, double baseUnitMagnitude, DimensionlessUnit unit) implements Dimensionless {
+  @Override
+  public Dimensionless copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDistance.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableDistance(double magnitude, double baseUnitMagnitude, DistanceUnit unit) implements Distance {
+  @Override
+  public Distance copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableEnergy.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableEnergy(double magnitude, double baseUnitMagnitude, EnergyUnit unit) implements Energy {
+  @Override
+  public Energy copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableForce.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableForce(double magnitude, double baseUnitMagnitude, ForceUnit unit) implements Force {
+  @Override
+  public Force copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableFrequency.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableFrequency(double magnitude, double baseUnitMagnitude, FrequencyUnit unit) implements Frequency {
+  @Override
+  public Frequency copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearAcceleration.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableLinearAcceleration(double magnitude, double baseUnitMagnitude, LinearAccelerationUnit unit) implements LinearAcceleration {
+  @Override
+  public LinearAcceleration copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearMomentum.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableLinearMomentum(double magnitude, double baseUnitMagnitude, LinearMomentumUnit unit) implements LinearMomentum {
+  @Override
+  public LinearMomentum copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearVelocity.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableLinearVelocity(double magnitude, double baseUnitMagnitude, LinearVelocityUnit unit) implements LinearVelocity {
+  @Override
+  public LinearVelocity copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMass.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableMass(double magnitude, double baseUnitMagnitude, MassUnit unit) implements Mass {
+  @Override
+  public Mass copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMomentOfInertia.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableMomentOfInertia(double magnitude, double baseUnitMagnitude, MomentOfInertiaUnit unit) implements MomentOfInertia {
+  @Override
+  public MomentOfInertia copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMult.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableMult<A extends Unit, B extends Unit>(double magnitude, double baseUnitMagnitude, MultUnit<A, B> unit) implements Mult<A, B> {
+  @Override
+  public Mult<A, B> copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePer.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutablePer<Dividend extends Unit, Divisor extends Unit>(double magnitude, double baseUnitMagnitude, PerUnit<Dividend, Divisor> unit) implements Per<Dividend, Divisor> {
+  @Override
+  public Per<Dividend, Divisor> copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePower.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutablePower(double magnitude, double baseUnitMagnitude, PowerUnit unit) implements Power {
+  @Override
+  public Power copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTemperature.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableTemperature(double magnitude, double baseUnitMagnitude, TemperatureUnit unit) implements Temperature {
+  @Override
+  public Temperature copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTime.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableTime(double magnitude, double baseUnitMagnitude, TimeUnit unit) implements Time {
+  @Override
+  public Time copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTorque.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableTorque(double magnitude, double baseUnitMagnitude, TorqueUnit unit) implements Torque {
+  @Override
+  public Torque copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVelocity.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableVelocity<D extends Unit>(double magnitude, double baseUnitMagnitude, VelocityUnit<D> unit) implements Velocity<D> {
+  @Override
+  public Velocity<D> copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltage.java

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public record ImmutableVoltage(double magnitude, double baseUnitMagnitude, VoltageUnit unit) implements Voltage {
+  @Override
+  public Voltage copy() {
+    return this;
+  }
+
+  @Override
+  public String toString() {
+    return toShortString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    return o instanceof Measure<?> m && isEquivalent(m);
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
+  static  LinearAcceleration ofRelativeUnits(double magnitude, LinearAccelerationUnit unit) {
+    return new ImmutableLinearAcceleration(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  LinearAcceleration ofBaseUnits(double baseUnitMagnitude, LinearAccelerationUnit unit) {
+    return new ImmutableLinearAcceleration(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  LinearAcceleration copy();
+
+  @Override
+  default MutLinearAcceleration mutableCopy() {
+    return new MutLinearAcceleration(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  LinearAccelerationUnit unit();
+
+  @Override
+  default LinearAccelerationUnit baseUnit() { return (LinearAccelerationUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(LinearAccelerationUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration unaryMinus() {
+    return (LinearAcceleration) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration plus(Measure<? extends LinearAccelerationUnit> other) {
+    return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration minus(Measure<? extends LinearAccelerationUnit> other) {
+    return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration times(double multiplier) {
+    return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default LinearAcceleration divide(double divisor) {
+    return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<LinearAccelerationUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<LinearAccelerationUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<LinearAccelerationUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<LinearAccelerationUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<LinearAccelerationUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<LinearAccelerationUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<LinearAccelerationUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<LinearAccelerationUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<LinearAccelerationUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<LinearAccelerationUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<LinearAccelerationUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<LinearAccelerationUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<LinearAccelerationUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default LinearAcceleration divide(Dimensionless divisor) {
+    return (LinearAcceleration) MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration times(Dimensionless multiplier) {
+    return (LinearAcceleration) MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<LinearAccelerationUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<LinearAccelerationUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<LinearAccelerationUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<LinearAccelerationUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<LinearAccelerationUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, ForceUnit> divide(Force divisor) {
+    return (Per<LinearAccelerationUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<LinearAccelerationUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default LinearVelocity divide(Frequency divisor) {
+    return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<LinearAccelerationUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(LinearAcceleration divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<LinearAccelerationUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<LinearAccelerationUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<LinearAccelerationUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<LinearAccelerationUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<LinearAccelerationUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, MassUnit> divide(Mass divisor) {
+    return (Per<LinearAccelerationUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<LinearAccelerationUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<LinearAccelerationUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<LinearAccelerationUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<LinearAccelerationUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<LinearAccelerationUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<LinearAccelerationUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<LinearAccelerationUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, PowerUnit> divide(Power divisor) {
+    return (Per<LinearAccelerationUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<LinearAccelerationUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<LinearAccelerationUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearVelocity times(Time multiplier) {
+    return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<LinearAccelerationUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<LinearAccelerationUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<LinearAccelerationUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<LinearAccelerationUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<LinearAccelerationUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<LinearAccelerationUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<LinearAccelerationUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface LinearMomentum extends Measure<LinearMomentumUnit> {
+  static  LinearMomentum ofRelativeUnits(double magnitude, LinearMomentumUnit unit) {
+    return new ImmutableLinearMomentum(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  LinearMomentum ofBaseUnits(double baseUnitMagnitude, LinearMomentumUnit unit) {
+    return new ImmutableLinearMomentum(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  LinearMomentum copy();
+
+  @Override
+  default MutLinearMomentum mutableCopy() {
+    return new MutLinearMomentum(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  LinearMomentumUnit unit();
+
+  @Override
+  default LinearMomentumUnit baseUnit() { return (LinearMomentumUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(LinearMomentumUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearMomentum unaryMinus() {
+    return (LinearMomentum) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearMomentum plus(Measure<? extends LinearMomentumUnit> other) {
+    return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearMomentum minus(Measure<? extends LinearMomentumUnit> other) {
+    return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearMomentum times(double multiplier) {
+    return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default LinearMomentum divide(double divisor) {
+    return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Force per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<LinearMomentumUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<LinearMomentumUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<LinearMomentumUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<LinearMomentumUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<LinearMomentumUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<LinearMomentumUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<LinearMomentumUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<LinearMomentumUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<LinearMomentumUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<LinearMomentumUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<LinearMomentumUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<LinearMomentumUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default LinearMomentum divide(Dimensionless divisor) {
+    return (LinearMomentum) KilogramMetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearMomentum times(Dimensionless multiplier) {
+    return (LinearMomentum) KilogramMetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<LinearMomentumUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<LinearMomentumUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<LinearMomentumUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<LinearMomentumUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<LinearMomentumUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, ForceUnit> divide(Force divisor) {
+    return (Per<LinearMomentumUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Force times(Frequency multiplier) {
+    return Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<LinearMomentumUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<LinearMomentumUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<LinearMomentumUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<LinearMomentumUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(LinearMomentum divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<LinearMomentumUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Mass divide(LinearVelocity divisor) {
+    return Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<LinearMomentumUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default LinearVelocity divide(Mass divisor) {
+    return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<LinearMomentumUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<LinearMomentumUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<LinearMomentumUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<LinearMomentumUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<LinearMomentumUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<LinearMomentumUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<LinearMomentumUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, PowerUnit> divide(Power divisor) {
+    return (Per<LinearMomentumUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<LinearMomentumUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<LinearMomentumUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<LinearMomentumUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Force divide(Time divisor) {
+    return Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<LinearMomentumUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<LinearMomentumUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<LinearMomentumUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<LinearMomentumUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<LinearMomentumUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<LinearMomentumUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface LinearVelocity extends Measure<LinearVelocityUnit> {
+  static  LinearVelocity ofRelativeUnits(double magnitude, LinearVelocityUnit unit) {
+    return new ImmutableLinearVelocity(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  LinearVelocity ofBaseUnits(double baseUnitMagnitude, LinearVelocityUnit unit) {
+    return new ImmutableLinearVelocity(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  LinearVelocity copy();
+
+  @Override
+  default MutLinearVelocity mutableCopy() {
+    return new MutLinearVelocity(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  LinearVelocityUnit unit();
+
+  @Override
+  default LinearVelocityUnit baseUnit() { return (LinearVelocityUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(LinearVelocityUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearVelocity unaryMinus() {
+    return (LinearVelocity) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearVelocity plus(Measure<? extends LinearVelocityUnit> other) {
+    return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearVelocity minus(Measure<? extends LinearVelocityUnit> other) {
+    return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearVelocity times(double multiplier) {
+    return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default LinearVelocity divide(double divisor) {
+    return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default LinearAcceleration per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<LinearVelocityUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<LinearVelocityUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<LinearVelocityUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<LinearVelocityUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<LinearVelocityUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<LinearVelocityUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<LinearVelocityUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<LinearVelocityUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<LinearVelocityUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<LinearVelocityUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<LinearVelocityUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<LinearVelocityUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default LinearVelocity divide(Dimensionless divisor) {
+    return (LinearVelocity) MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearVelocity times(Dimensionless multiplier) {
+    return (LinearVelocity) MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<LinearVelocityUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<LinearVelocityUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<LinearVelocityUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<LinearVelocityUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<LinearVelocityUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, ForceUnit> divide(Force divisor) {
+    return (Per<LinearVelocityUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearAcceleration times(Frequency multiplier) {
+    return MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<LinearVelocityUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<LinearVelocityUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<LinearVelocityUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<LinearVelocityUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<LinearVelocityUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<LinearVelocityUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(LinearVelocity divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<LinearVelocityUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, MassUnit> divide(Mass divisor) {
+    return (Per<LinearVelocityUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<LinearVelocityUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<LinearVelocityUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<LinearVelocityUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<LinearVelocityUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<LinearVelocityUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<LinearVelocityUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<LinearVelocityUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, PowerUnit> divide(Power divisor) {
+    return (Per<LinearVelocityUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<LinearVelocityUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<LinearVelocityUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Distance times(Time multiplier) {
+    return Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration divide(Time divisor) {
+    return MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<LinearVelocityUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<LinearVelocityUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<LinearVelocityUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<LinearVelocityUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<LinearVelocityUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<LinearVelocityUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Mass extends Measure<MassUnit> {
+  static  Mass ofRelativeUnits(double magnitude, MassUnit unit) {
+    return new ImmutableMass(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Mass ofBaseUnits(double baseUnitMagnitude, MassUnit unit) {
+    return new ImmutableMass(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Mass copy();
+
+  @Override
+  default MutMass mutableCopy() {
+    return new MutMass(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  MassUnit unit();
+
+  @Override
+  default MassUnit baseUnit() { return (MassUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(MassUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Mass unaryMinus() {
+    return (Mass) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Mass plus(Measure<? extends MassUnit> other) {
+    return (Mass) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Mass minus(Measure<? extends MassUnit> other) {
+    return (Mass) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Mass times(double multiplier) {
+    return (Mass) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Mass divide(double divisor) {
+    return (Mass) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<MassUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<MassUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<MassUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<MassUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<MassUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<MassUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<MassUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<MassUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<MassUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<MassUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<MassUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<MassUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<MassUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<MassUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Mass divide(Dimensionless divisor) {
+    return (Mass) Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Mass times(Dimensionless multiplier) {
+    return (Mass) Kilograms.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MassUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<MassUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<MassUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<MassUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<MassUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<MassUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, ForceUnit> divide(Force divisor) {
+    return (Per<MassUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<MassUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<MassUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Force times(LinearAcceleration multiplier) {
+    return Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<MassUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<MassUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<MassUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<MassUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<MassUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<MassUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<MassUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Mass divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MassUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<MassUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<MassUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<MassUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<MassUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<MassUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<MassUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<MassUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, PowerUnit> divide(Power divisor) {
+    return (Per<MassUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<MassUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<MassUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<MassUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<MassUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MassUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<MassUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<MassUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<MassUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<MassUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<MassUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<MassUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
+  static  MomentOfInertia ofRelativeUnits(double magnitude, MomentOfInertiaUnit unit) {
+    return new ImmutableMomentOfInertia(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  MomentOfInertia ofBaseUnits(double baseUnitMagnitude, MomentOfInertiaUnit unit) {
+    return new ImmutableMomentOfInertia(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  MomentOfInertia copy();
+
+  @Override
+  default MutMomentOfInertia mutableCopy() {
+    return new MutMomentOfInertia(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  MomentOfInertiaUnit unit();
+
+  @Override
+  default MomentOfInertiaUnit baseUnit() { return (MomentOfInertiaUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(MomentOfInertiaUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default MomentOfInertia unaryMinus() {
+    return (MomentOfInertia) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default MomentOfInertia plus(Measure<? extends MomentOfInertiaUnit> other) {
+    return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default MomentOfInertia minus(Measure<? extends MomentOfInertiaUnit> other) {
+    return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default MomentOfInertia times(double multiplier) {
+    return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default MomentOfInertia divide(double divisor) {
+    return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<MomentOfInertiaUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<MomentOfInertiaUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<MomentOfInertiaUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<MomentOfInertiaUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<MomentOfInertiaUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<MomentOfInertiaUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<MomentOfInertiaUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<MomentOfInertiaUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<MomentOfInertiaUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularMomentum times(AngularVelocity multiplier) {
+    return KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<MomentOfInertiaUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<MomentOfInertiaUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<MomentOfInertiaUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default MomentOfInertia divide(Dimensionless divisor) {
+    return (MomentOfInertia) KilogramSquareMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default MomentOfInertia times(Dimensionless multiplier) {
+    return (MomentOfInertia) KilogramSquareMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<MomentOfInertiaUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<MomentOfInertiaUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<MomentOfInertiaUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<MomentOfInertiaUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<MomentOfInertiaUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, ForceUnit> divide(Force divisor) {
+    return (Per<MomentOfInertiaUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<MomentOfInertiaUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<MomentOfInertiaUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<MomentOfInertiaUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<MomentOfInertiaUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<MomentOfInertiaUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<MomentOfInertiaUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<MomentOfInertiaUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<MomentOfInertiaUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<MomentOfInertiaUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, MassUnit> divide(Mass divisor) {
+    return (Per<MomentOfInertiaUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<MomentOfInertiaUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(MomentOfInertia divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<MomentOfInertiaUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<MomentOfInertiaUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<MomentOfInertiaUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<MomentOfInertiaUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<MomentOfInertiaUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, PowerUnit> divide(Power divisor) {
+    return (Per<MomentOfInertiaUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<MomentOfInertiaUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<MomentOfInertiaUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<MomentOfInertiaUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<MomentOfInertiaUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<MomentOfInertiaUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<MomentOfInertiaUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<MomentOfInertiaUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<MomentOfInertiaUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<MomentOfInertiaUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<MomentOfInertiaUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A, B>> {
+  static <A extends Unit, B extends Unit> Mult<A, B> ofRelativeUnits(double magnitude, MultUnit<A, B> unit) {
+    return new ImmutableMult<A, B>(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static <A extends Unit, B extends Unit> Mult<A, B> ofBaseUnits(double baseUnitMagnitude, MultUnit<A, B> unit) {
+    return new ImmutableMult<A, B>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Mult<A, B> copy();
+
+  @Override
+  default MutMult<A, B> mutableCopy() {
+    return new MutMult<A, B>(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  MultUnit<A, B> unit();
+
+  @Override
+  default MultUnit<A, B> baseUnit() { return (MultUnit<A, B>) unit().getBaseUnit(); }
+
+  @Override
+  default double in(MultUnit<A, B> unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Mult<A, B> unaryMinus() {
+    return (Mult<A, B>) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Mult<A, B> plus(Measure<? extends MultUnit<A, B>> other) {
+    return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Mult<A, B> minus(Measure<? extends MultUnit<A, B>> other) {
+    return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Mult<A, B> times(double multiplier) {
+    return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Mult<A, B> divide(double divisor) {
+    return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<MultUnit<A, B>> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<MultUnit<A, B>, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<MultUnit<A, B>, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, AngleUnit> times(Angle multiplier) {
+    return (Mult<MultUnit<A, B>, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, AngleUnit> divide(Angle divisor) {
+    return (Per<MultUnit<A, B>, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<MultUnit<A, B>, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<MultUnit<A, B>, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<MultUnit<A, B>, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<MultUnit<A, B>, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<MultUnit<A, B>, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<MultUnit<A, B>, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, CurrentUnit> times(Current multiplier) {
+    return (Mult<MultUnit<A, B>, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, CurrentUnit> divide(Current divisor) {
+    return (Per<MultUnit<A, B>, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Mult<A, B> divide(Dimensionless divisor) {
+    return (Mult<A, B>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Mult<A, B> times(Dimensionless multiplier) {
+    return (Mult<A, B>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, DistanceUnit> times(Distance multiplier) {
+    return (Mult<MultUnit<A, B>, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, DistanceUnit> divide(Distance divisor) {
+    return (Per<MultUnit<A, B>, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, EnergyUnit> times(Energy multiplier) {
+    return (Mult<MultUnit<A, B>, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, EnergyUnit> divide(Energy divisor) {
+    return (Per<MultUnit<A, B>, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, ForceUnit> times(Force multiplier) {
+    return (Mult<MultUnit<A, B>, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, ForceUnit> divide(Force divisor) {
+    return (Per<MultUnit<A, B>, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<MultUnit<A, B>, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<MultUnit<A, B>, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<MultUnit<A, B>, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<MultUnit<A, B>, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<MultUnit<A, B>, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<MultUnit<A, B>, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<MultUnit<A, B>, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<MultUnit<A, B>, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, MassUnit> times(Mass multiplier) {
+    return (Mult<MultUnit<A, B>, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, MassUnit> divide(Mass divisor) {
+    return (Per<MultUnit<A, B>, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<MultUnit<A, B>, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<MultUnit<A, B>, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<MultUnit<A, B>, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<MultUnit<A, B>, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<MultUnit<A, B>, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<MultUnit<A, B>, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, PowerUnit> times(Power multiplier) {
+    return (Mult<MultUnit<A, B>, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, PowerUnit> divide(Power divisor) {
+    return (Per<MultUnit<A, B>, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<MultUnit<A, B>, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<MultUnit<A, B>, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, TimeUnit> times(Time multiplier) {
+    return (Mult<MultUnit<A, B>, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<MultUnit<A, B>> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, TorqueUnit> times(Torque multiplier) {
+    return (Mult<MultUnit<A, B>, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, TorqueUnit> divide(Torque divisor) {
+    return (Per<MultUnit<A, B>, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<MultUnit<A, B>, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<MultUnit<A, B>, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<MultUnit<A, B>, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, VoltageUnit> divide(Voltage divisor) {
+    return (Per<MultUnit<A, B>, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAcceleration.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutAcceleration<D extends Unit>
+  extends MutableMeasureBase<AccelerationUnit<D>, Acceleration<D>, MutAcceleration<D>>
+  implements Acceleration<D> {
+  public MutAcceleration(double magnitude, double baseUnitMagnitude, AccelerationUnit<D> unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Acceleration<D> copy() {
+    return new ImmutableAcceleration<D>(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngle.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutAngle
+  extends MutableMeasureBase<AngleUnit, Angle, MutAngle>
+  implements Angle {
+  public MutAngle(double magnitude, double baseUnitMagnitude, AngleUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Angle copy() {
+    return new ImmutableAngle(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularAcceleration.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutAngularAcceleration
+  extends MutableMeasureBase<AngularAccelerationUnit, AngularAcceleration, MutAngularAcceleration>
+  implements AngularAcceleration {
+  public MutAngularAcceleration(double magnitude, double baseUnitMagnitude, AngularAccelerationUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public AngularAcceleration copy() {
+    return new ImmutableAngularAcceleration(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularMomentum.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutAngularMomentum
+  extends MutableMeasureBase<AngularMomentumUnit, AngularMomentum, MutAngularMomentum>
+  implements AngularMomentum {
+  public MutAngularMomentum(double magnitude, double baseUnitMagnitude, AngularMomentumUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public AngularMomentum copy() {
+    return new ImmutableAngularMomentum(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularVelocity.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutAngularVelocity
+  extends MutableMeasureBase<AngularVelocityUnit, AngularVelocity, MutAngularVelocity>
+  implements AngularVelocity {
+  public MutAngularVelocity(double magnitude, double baseUnitMagnitude, AngularVelocityUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public AngularVelocity copy() {
+    return new ImmutableAngularVelocity(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutCurrent.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutCurrent
+  extends MutableMeasureBase<CurrentUnit, Current, MutCurrent>
+  implements Current {
+  public MutCurrent(double magnitude, double baseUnitMagnitude, CurrentUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Current copy() {
+    return new ImmutableCurrent(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDimensionless.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutDimensionless
+  extends MutableMeasureBase<DimensionlessUnit, Dimensionless, MutDimensionless>
+  implements Dimensionless {
+  public MutDimensionless(double magnitude, double baseUnitMagnitude, DimensionlessUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Dimensionless copy() {
+    return new ImmutableDimensionless(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDistance.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutDistance
+  extends MutableMeasureBase<DistanceUnit, Distance, MutDistance>
+  implements Distance {
+  public MutDistance(double magnitude, double baseUnitMagnitude, DistanceUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Distance copy() {
+    return new ImmutableDistance(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutEnergy.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutEnergy
+  extends MutableMeasureBase<EnergyUnit, Energy, MutEnergy>
+  implements Energy {
+  public MutEnergy(double magnitude, double baseUnitMagnitude, EnergyUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Energy copy() {
+    return new ImmutableEnergy(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutForce.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutForce
+  extends MutableMeasureBase<ForceUnit, Force, MutForce>
+  implements Force {
+  public MutForce(double magnitude, double baseUnitMagnitude, ForceUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Force copy() {
+    return new ImmutableForce(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutFrequency.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutFrequency
+  extends MutableMeasureBase<FrequencyUnit, Frequency, MutFrequency>
+  implements Frequency {
+  public MutFrequency(double magnitude, double baseUnitMagnitude, FrequencyUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Frequency copy() {
+    return new ImmutableFrequency(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearAcceleration.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutLinearAcceleration
+  extends MutableMeasureBase<LinearAccelerationUnit, LinearAcceleration, MutLinearAcceleration>
+  implements LinearAcceleration {
+  public MutLinearAcceleration(double magnitude, double baseUnitMagnitude, LinearAccelerationUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public LinearAcceleration copy() {
+    return new ImmutableLinearAcceleration(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearMomentum.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutLinearMomentum
+  extends MutableMeasureBase<LinearMomentumUnit, LinearMomentum, MutLinearMomentum>
+  implements LinearMomentum {
+  public MutLinearMomentum(double magnitude, double baseUnitMagnitude, LinearMomentumUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public LinearMomentum copy() {
+    return new ImmutableLinearMomentum(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearVelocity.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutLinearVelocity
+  extends MutableMeasureBase<LinearVelocityUnit, LinearVelocity, MutLinearVelocity>
+  implements LinearVelocity {
+  public MutLinearVelocity(double magnitude, double baseUnitMagnitude, LinearVelocityUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public LinearVelocity copy() {
+    return new ImmutableLinearVelocity(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMass.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutMass
+  extends MutableMeasureBase<MassUnit, Mass, MutMass>
+  implements Mass {
+  public MutMass(double magnitude, double baseUnitMagnitude, MassUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Mass copy() {
+    return new ImmutableMass(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMomentOfInertia.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutMomentOfInertia
+  extends MutableMeasureBase<MomentOfInertiaUnit, MomentOfInertia, MutMomentOfInertia>
+  implements MomentOfInertia {
+  public MutMomentOfInertia(double magnitude, double baseUnitMagnitude, MomentOfInertiaUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public MomentOfInertia copy() {
+    return new ImmutableMomentOfInertia(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMult.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutMult<A extends Unit, B extends Unit>
+  extends MutableMeasureBase<MultUnit<A, B>, Mult<A, B>, MutMult<A, B>>
+  implements Mult<A, B> {
+  public MutMult(double magnitude, double baseUnitMagnitude, MultUnit<A, B> unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Mult<A, B> copy() {
+    return new ImmutableMult<A, B>(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPer.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutPer<Dividend extends Unit, Divisor extends Unit>
+  extends MutableMeasureBase<PerUnit<Dividend, Divisor>, Per<Dividend, Divisor>, MutPer<Dividend, Divisor>>
+  implements Per<Dividend, Divisor> {
+  public MutPer(double magnitude, double baseUnitMagnitude, PerUnit<Dividend, Divisor> unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Per<Dividend, Divisor> copy() {
+    return new ImmutablePer<Dividend, Divisor>(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPower.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutPower
+  extends MutableMeasureBase<PowerUnit, Power, MutPower>
+  implements Power {
+  public MutPower(double magnitude, double baseUnitMagnitude, PowerUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Power copy() {
+    return new ImmutablePower(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTemperature.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutTemperature
+  extends MutableMeasureBase<TemperatureUnit, Temperature, MutTemperature>
+  implements Temperature {
+  public MutTemperature(double magnitude, double baseUnitMagnitude, TemperatureUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Temperature copy() {
+    return new ImmutableTemperature(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTime.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutTime
+  extends MutableMeasureBase<TimeUnit, Time, MutTime>
+  implements Time {
+  public MutTime(double magnitude, double baseUnitMagnitude, TimeUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Time copy() {
+    return new ImmutableTime(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTorque.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutTorque
+  extends MutableMeasureBase<TorqueUnit, Torque, MutTorque>
+  implements Torque {
+  public MutTorque(double magnitude, double baseUnitMagnitude, TorqueUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Torque copy() {
+    return new ImmutableTorque(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVelocity.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutVelocity<D extends Unit>
+  extends MutableMeasureBase<VelocityUnit<D>, Velocity<D>, MutVelocity<D>>
+  implements Velocity<D> {
+  public MutVelocity(double magnitude, double baseUnitMagnitude, VelocityUnit<D> unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Velocity<D> copy() {
+    return new ImmutableVelocity<D>(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltage.java

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+import edu.wpi.first.units.mutable.MutableMeasureBase;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public final class MutVoltage
+  extends MutableMeasureBase<VoltageUnit, Voltage, MutVoltage>
+  implements Voltage {
+  public MutVoltage(double magnitude, double baseUnitMagnitude, VoltageUnit unit) {
+    super(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Voltage copy() {
+    return new ImmutableVoltage(magnitude(), baseUnitMagnitude(), unit());
+  }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java

@@ -0,0 +1,341 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measure<PerUnit<Dividend, Divisor>> {
+  static <Dividend extends Unit, Divisor extends Unit> Per<Dividend, Divisor> ofRelativeUnits(double magnitude, PerUnit<Dividend, Divisor> unit) {
+    return new ImmutablePer<Dividend, Divisor>(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static <Dividend extends Unit, Divisor extends Unit> Per<Dividend, Divisor> ofBaseUnits(double baseUnitMagnitude, PerUnit<Dividend, Divisor> unit) {
+    return new ImmutablePer<Dividend, Divisor>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Per<Dividend, Divisor> copy();
+
+  @Override
+  default MutPer<Dividend, Divisor> mutableCopy() {
+    return new MutPer<Dividend, Divisor>(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  PerUnit<Dividend, Divisor> unit();
+
+  @Override
+  default PerUnit<Dividend, Divisor> baseUnit() { return (PerUnit<Dividend, Divisor>) unit().getBaseUnit(); }
+
+  @Override
+  default double in(PerUnit<Dividend, Divisor> unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<Dividend, Divisor> unaryMinus() {
+    return (Per<Dividend, Divisor>) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<Dividend, Divisor> plus(Measure<? extends PerUnit<Dividend, Divisor>> other) {
+    return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<Dividend, Divisor> minus(Measure<? extends PerUnit<Dividend, Divisor>> other) {
+    return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<Dividend, Divisor> times(double multiplier) {
+    return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Per<Dividend, Divisor> divide(double divisor) {
+    return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<PerUnit<Dividend, Divisor>> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, AngleUnit> times(Angle multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, AngleUnit> divide(Angle divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, CurrentUnit> times(Current multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, CurrentUnit> divide(Current divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Per<Dividend, Divisor> divide(Dimensionless divisor) {
+    return (Per<Dividend, Divisor>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<Dividend, Divisor> times(Dimensionless multiplier) {
+    return (Per<Dividend, Divisor>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, DistanceUnit> times(Distance multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, DistanceUnit> divide(Distance divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, EnergyUnit> times(Energy multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, EnergyUnit> divide(Energy divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, ForceUnit> times(Force multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, ForceUnit> divide(Force divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, MassUnit> times(Mass multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, MassUnit> divide(Mass divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, PowerUnit> times(Power multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, PowerUnit> divide(Power divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, TimeUnit> times(Time multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<PerUnit<Dividend, Divisor>> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, TorqueUnit> times(Torque multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, TorqueUnit> divide(Torque divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, VoltageUnit> divide(Voltage divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, VoltageUnit>) Measure.super.divide(divisor);
+  }
+default Measure<Dividend> timesDivisor(Measure<? extends Divisor> multiplier) {
+  return (Measure<Dividend>) baseUnit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+}
+
+default Measure<? extends PerUnit<Divisor, Dividend>> reciprocal() {
+  // May return a velocity if Divisor == TimeUnit, so we can't guarantee a "Per" instance
+  return baseUnit().reciprocal().ofBaseUnits(1 / baseUnitMagnitude());
+}
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Power extends Measure<PowerUnit> {
+  static  Power ofRelativeUnits(double magnitude, PowerUnit unit) {
+    return new ImmutablePower(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Power ofBaseUnits(double baseUnitMagnitude, PowerUnit unit) {
+    return new ImmutablePower(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Power copy();
+
+  @Override
+  default MutPower mutableCopy() {
+    return new MutPower(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  PowerUnit unit();
+
+  @Override
+  default PowerUnit baseUnit() { return (PowerUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(PowerUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Power unaryMinus() {
+    return (Power) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Power plus(Measure<? extends PowerUnit> other) {
+    return (Power) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Power minus(Measure<? extends PowerUnit> other) {
+    return (Power) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Power times(double multiplier) {
+    return (Power) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Power divide(double divisor) {
+    return (Power) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<PowerUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<PowerUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<PowerUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<PowerUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<PowerUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<PowerUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<PowerUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<PowerUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<PowerUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<PowerUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<PowerUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<PowerUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<PowerUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Voltage divide(Current divisor) {
+    return Volts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Power divide(Dimensionless divisor) {
+    return (Power) Watts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Power times(Dimensionless multiplier) {
+    return (Power) Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<PowerUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<PowerUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<PowerUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<PowerUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Frequency divide(Energy divisor) {
+    return Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<PowerUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<PowerUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, ForceUnit> divide(Force divisor) {
+    return (Per<PowerUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<PowerUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<PowerUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<PowerUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<PowerUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<PowerUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<PowerUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<PowerUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<PowerUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<PowerUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, MassUnit> divide(Mass divisor) {
+    return (Per<PowerUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<PowerUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<PowerUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<PowerUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<PowerUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<PowerUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<PowerUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<PowerUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Power divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<PowerUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<PowerUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<PowerUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Energy times(Time multiplier) {
+    return Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<PowerUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<PowerUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<PowerUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<PowerUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<PowerUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<PowerUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<PowerUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Current divide(Voltage divisor) {
+    return Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Temperature extends Measure<TemperatureUnit> {
+  static  Temperature ofRelativeUnits(double magnitude, TemperatureUnit unit) {
+    return new ImmutableTemperature(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Temperature ofBaseUnits(double baseUnitMagnitude, TemperatureUnit unit) {
+    return new ImmutableTemperature(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Temperature copy();
+
+  @Override
+  default MutTemperature mutableCopy() {
+    return new MutTemperature(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  TemperatureUnit unit();
+
+  @Override
+  default TemperatureUnit baseUnit() { return (TemperatureUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(TemperatureUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Temperature unaryMinus() {
+    return (Temperature) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Temperature plus(Measure<? extends TemperatureUnit> other) {
+    return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Temperature minus(Measure<? extends TemperatureUnit> other) {
+    return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Temperature times(double multiplier) {
+    return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Temperature divide(double divisor) {
+    return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<TemperatureUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<TemperatureUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<TemperatureUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<TemperatureUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<TemperatureUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<TemperatureUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<TemperatureUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<TemperatureUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<TemperatureUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<TemperatureUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<TemperatureUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<TemperatureUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<TemperatureUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Temperature divide(Dimensionless divisor) {
+    return (Temperature) Kelvin.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Temperature times(Dimensionless multiplier) {
+    return (Temperature) Kelvin.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<TemperatureUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<TemperatureUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<TemperatureUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<TemperatureUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<TemperatureUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, ForceUnit> divide(Force divisor) {
+    return (Per<TemperatureUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<TemperatureUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<TemperatureUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<TemperatureUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<TemperatureUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<TemperatureUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<TemperatureUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<TemperatureUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<TemperatureUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<TemperatureUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, MassUnit> divide(Mass divisor) {
+    return (Per<TemperatureUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<TemperatureUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<TemperatureUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<TemperatureUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<TemperatureUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<TemperatureUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<TemperatureUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<TemperatureUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, PowerUnit> divide(Power divisor) {
+    return (Per<TemperatureUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<TemperatureUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Temperature divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<TemperatureUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<TemperatureUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<TemperatureUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<TemperatureUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<TemperatureUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<TemperatureUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<TemperatureUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<TemperatureUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Time extends Measure<TimeUnit> {
+  static  Time ofRelativeUnits(double magnitude, TimeUnit unit) {
+    return new ImmutableTime(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Time ofBaseUnits(double baseUnitMagnitude, TimeUnit unit) {
+    return new ImmutableTime(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Time copy();
+
+  @Override
+  default MutTime mutableCopy() {
+    return new MutTime(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  TimeUnit unit();
+
+  @Override
+  default TimeUnit baseUnit() { return (TimeUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(TimeUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Time unaryMinus() {
+    return (Time) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Time plus(Measure<? extends TimeUnit> other) {
+    return (Time) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Time minus(Measure<? extends TimeUnit> other) {
+    return (Time) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Time times(double multiplier) {
+    return (Time) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Time divide(double divisor) {
+    return (Time) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Dimensionless per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<TimeUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<TimeUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<TimeUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<TimeUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<TimeUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularVelocity times(AngularAcceleration multiplier) {
+    return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<TimeUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<TimeUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<TimeUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<TimeUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Angle times(AngularVelocity multiplier) {
+    return Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<TimeUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<TimeUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<TimeUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<TimeUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Time divide(Dimensionless divisor) {
+    return (Time) Seconds.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Time times(Dimensionless multiplier) {
+    return (Time) Seconds.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TimeUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<TimeUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<TimeUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<TimeUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<TimeUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<TimeUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, ForceUnit> divide(Force divisor) {
+    return (Per<TimeUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Dimensionless times(Frequency multiplier) {
+    return Value.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<TimeUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<TimeUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearVelocity times(LinearAcceleration multiplier) {
+    return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<TimeUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<TimeUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<TimeUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<TimeUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Distance times(LinearVelocity multiplier) {
+    return Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<TimeUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<TimeUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<TimeUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, MassUnit> divide(Mass divisor) {
+    return (Per<TimeUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<TimeUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<TimeUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<TimeUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<TimeUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<TimeUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<TimeUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<TimeUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, PowerUnit> divide(Power divisor) {
+    return (Per<TimeUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<TimeUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<TimeUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<TimeUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Time divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TimeUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<TimeUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<TimeUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<TimeUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<TimeUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<TimeUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<TimeUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+default Frequency asFrequency() { return Hertz.of(1 / baseUnitMagnitude()); }
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Torque extends Measure<TorqueUnit> {
+  static  Torque ofRelativeUnits(double magnitude, TorqueUnit unit) {
+    return new ImmutableTorque(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Torque ofBaseUnits(double baseUnitMagnitude, TorqueUnit unit) {
+    return new ImmutableTorque(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Torque copy();
+
+  @Override
+  default MutTorque mutableCopy() {
+    return new MutTorque(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  TorqueUnit unit();
+
+  @Override
+  default TorqueUnit baseUnit() { return (TorqueUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(TorqueUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Torque unaryMinus() {
+    return (Torque) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Torque plus(Measure<? extends TorqueUnit> other) {
+    return (Torque) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Torque minus(Measure<? extends TorqueUnit> other) {
+    return (Torque) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Torque times(double multiplier) {
+    return (Torque) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Torque divide(double divisor) {
+    return (Torque) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<TorqueUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<TorqueUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<TorqueUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<TorqueUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<TorqueUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<TorqueUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<TorqueUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<TorqueUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<TorqueUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<TorqueUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<TorqueUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<TorqueUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<TorqueUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Torque divide(Dimensionless divisor) {
+    return (Torque) NewtonMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Torque times(Dimensionless multiplier) {
+    return (Torque) NewtonMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<TorqueUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Force divide(Distance divisor) {
+    return Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<TorqueUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<TorqueUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<TorqueUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Distance divide(Force divisor) {
+    return Meters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<TorqueUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<TorqueUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<TorqueUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<TorqueUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<TorqueUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<TorqueUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<TorqueUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<TorqueUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<TorqueUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, MassUnit> divide(Mass divisor) {
+    return (Per<TorqueUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<TorqueUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<TorqueUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<TorqueUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<TorqueUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<TorqueUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<TorqueUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<TorqueUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, PowerUnit> divide(Power divisor) {
+    return (Per<TorqueUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<TorqueUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<TorqueUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<TorqueUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<TorqueUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<TorqueUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Torque divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<TorqueUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<TorqueUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<TorqueUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<TorqueUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
+  static <D extends Unit> Velocity<D> ofRelativeUnits(double magnitude, VelocityUnit<D> unit) {
+    return new ImmutableVelocity<D>(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static <D extends Unit> Velocity<D> ofBaseUnits(double baseUnitMagnitude, VelocityUnit<D> unit) {
+    return new ImmutableVelocity<D>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Velocity<D> copy();
+
+  @Override
+  default MutVelocity<D> mutableCopy() {
+    return new MutVelocity<D>(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  VelocityUnit<D> unit();
+
+  @Override
+  default VelocityUnit<D> baseUnit() { return (VelocityUnit<D>) unit().getBaseUnit(); }
+
+  @Override
+  default double in(VelocityUnit<D> unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<D> unaryMinus() {
+    return (Velocity<D>) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<D> plus(Measure<? extends VelocityUnit<D>> other) {
+    return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<D> minus(Measure<? extends VelocityUnit<D>> other) {
+    return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<D> times(double multiplier) {
+    return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Velocity<D> divide(double divisor) {
+    return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<VelocityUnit<D>> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<VelocityUnit<D>, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<VelocityUnit<D>, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, AngleUnit> times(Angle multiplier) {
+    return (Mult<VelocityUnit<D>, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, AngleUnit> divide(Angle divisor) {
+    return (Per<VelocityUnit<D>, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<VelocityUnit<D>, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<VelocityUnit<D>, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<VelocityUnit<D>, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<VelocityUnit<D>, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<VelocityUnit<D>, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<VelocityUnit<D>, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, CurrentUnit> times(Current multiplier) {
+    return (Mult<VelocityUnit<D>, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, CurrentUnit> divide(Current divisor) {
+    return (Per<VelocityUnit<D>, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Velocity<D> divide(Dimensionless divisor) {
+    return (Velocity<D>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<D> times(Dimensionless multiplier) {
+    return (Velocity<D>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, DistanceUnit> times(Distance multiplier) {
+    return (Mult<VelocityUnit<D>, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, DistanceUnit> divide(Distance divisor) {
+    return (Per<VelocityUnit<D>, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, EnergyUnit> times(Energy multiplier) {
+    return (Mult<VelocityUnit<D>, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, EnergyUnit> divide(Energy divisor) {
+    return (Per<VelocityUnit<D>, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, ForceUnit> times(Force multiplier) {
+    return (Mult<VelocityUnit<D>, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, ForceUnit> divide(Force divisor) {
+    return (Per<VelocityUnit<D>, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<VelocityUnit<D>, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<VelocityUnit<D>, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<VelocityUnit<D>, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<VelocityUnit<D>, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<VelocityUnit<D>, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<VelocityUnit<D>, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<VelocityUnit<D>, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<VelocityUnit<D>, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, MassUnit> times(Mass multiplier) {
+    return (Mult<VelocityUnit<D>, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, MassUnit> divide(Mass divisor) {
+    return (Per<VelocityUnit<D>, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<VelocityUnit<D>, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<VelocityUnit<D>, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<VelocityUnit<D>, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<VelocityUnit<D>, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<VelocityUnit<D>, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<VelocityUnit<D>, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, PowerUnit> times(Power multiplier) {
+    return (Mult<VelocityUnit<D>, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, PowerUnit> divide(Power divisor) {
+    return (Per<VelocityUnit<D>, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<VelocityUnit<D>, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<VelocityUnit<D>, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, TimeUnit> times(Time multiplier) {
+    return (Mult<VelocityUnit<D>, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<VelocityUnit<D>> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, TorqueUnit> times(Torque multiplier) {
+    return (Mult<VelocityUnit<D>, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, TorqueUnit> divide(Torque divisor) {
+    return (Per<VelocityUnit<D>, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<VelocityUnit<D>, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<VelocityUnit<D>, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<VelocityUnit<D>, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, VoltageUnit> divide(Voltage divisor) {
+    return (Per<VelocityUnit<D>, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}

wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java

@@ -0,0 +1,334 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
+
+package edu.wpi.first.units.measure;
+
+import static edu.wpi.first.units.Units.*;
+import edu.wpi.first.units.*;
+
+@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
+public interface Voltage extends Measure<VoltageUnit> {
+  static  Voltage ofRelativeUnits(double magnitude, VoltageUnit unit) {
+    return new ImmutableVoltage(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Voltage ofBaseUnits(double baseUnitMagnitude, VoltageUnit unit) {
+    return new ImmutableVoltage(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Voltage copy();
+
+  @Override
+  default MutVoltage mutableCopy() {
+    return new MutVoltage(magnitude(), baseUnitMagnitude(), unit());
+  }
+
+  @Override
+  VoltageUnit unit();
+
+  @Override
+  default VoltageUnit baseUnit() { return (VoltageUnit) unit().getBaseUnit(); }
+
+  @Override
+  default double in(VoltageUnit unit) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Voltage unaryMinus() {
+    return (Voltage) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Voltage plus(Measure<? extends VoltageUnit> other) {
+    return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Voltage minus(Measure<? extends VoltageUnit> other) {
+    return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Voltage times(double multiplier) {
+    return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Voltage divide(double divisor) {
+    return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<VoltageUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<VoltageUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<VoltageUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<VoltageUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<VoltageUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<VoltageUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<VoltageUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<VoltageUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<VoltageUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<VoltageUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<VoltageUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Power times(Current multiplier) {
+    return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<VoltageUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<VoltageUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Voltage divide(Dimensionless divisor) {
+    return (Voltage) Volts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Voltage times(Dimensionless multiplier) {
+    return (Voltage) Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<VoltageUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<VoltageUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<VoltageUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<VoltageUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<VoltageUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, ForceUnit> divide(Force divisor) {
+    return (Per<VoltageUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<VoltageUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<VoltageUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<VoltageUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<VoltageUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<VoltageUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<VoltageUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<VoltageUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<VoltageUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<VoltageUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, MassUnit> divide(Mass divisor) {
+    return (Per<VoltageUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<VoltageUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<VoltageUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<VoltageUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<VoltageUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<VoltageUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<VoltageUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<VoltageUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, PowerUnit> divide(Power divisor) {
+    return (Per<VoltageUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<VoltageUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<VoltageUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<VoltageUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<VoltageUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<VoltageUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<VoltageUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<VoltageUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<VoltageUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<VoltageUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Voltage divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+}

wpiunits/src/main/java/edu/wpi/first/units/AccelerationUnit.java

@@ -0,0 +1,113 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.Acceleration;
+import edu.wpi.first.units.measure.ImmutableAcceleration;
+import edu.wpi.first.units.measure.MutAcceleration;
+
+/**
+ * A generic unit of acceleration.
+ *
+ * <p><strong>NOTE:</strong> This type is not compatible with unit-specific accelerations like
+ * {@link edu.wpi.first.units.measure.LinearAcceleration}. Authors of APIs that need to interact
+ * with all types should consider using a generic {@code Measure<? extends PerUnit<? extends
+ * PerUnit<[dimension>], TimeUnit>, TimeUnit>}. Bounded wildcards are necessary in order to
+ * interoperate with <i>any</i> subclass of the {@link edu.wpi.first.units.measure.Per} measurement
+ * type.
+ *
+ * @param <D> the unit of the accelerating quantity
+ */
+public final class AccelerationUnit<D extends Unit> extends PerUnit<VelocityUnit<D>, TimeUnit> {
+  @SuppressWarnings({"rawtypes", "unchecked"})
+  private static final CombinatoryUnitCache<VelocityUnit, TimeUnit, AccelerationUnit> cache =
+      new CombinatoryUnitCache<>(AccelerationUnit::new);
+
+  AccelerationUnit(VelocityUnit<D> velocity, TimeUnit period) {
+    super(
+        velocity.isBaseUnit() && period.isBaseUnit()
+            ? null
+            : combine(velocity.getBaseUnit(), period.getBaseUnit()),
+        velocity,
+        period);
+  }
+
+  AccelerationUnit(
+      AccelerationUnit<D> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public Acceleration<D> of(double magnitude) {
+    return new ImmutableAcceleration<>(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Acceleration<D> ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableAcceleration<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public Acceleration<D> zero() {
+    return (Acceleration<D>) (Acceleration) super.zero();
+  }
+
+  @Override
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public Acceleration<D> one() {
+    return (Acceleration<D>) (Acceleration) super.one();
+  }
+
+  @Override
+  public MutAcceleration<D> mutable(double initialMagnitude) {
+    return new MutAcceleration<>(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  @Override
+  public VelocityUnit<AccelerationUnit<D>> per(TimeUnit time) {
+    return VelocityUnit.combine(this, time);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<AccelerationUnit<D>, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another time unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other time unit
+   * @param otherUnit the other time unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, AccelerationUnit<D> otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Combines a generic velocity and time period into a unit of acceleration.
+   *
+   * @param velocity the unit of velocity
+   * @param period the unit of the time period of acceleration
+   * @param <D> the unit of the accelerating quantity
+   * @return the combined acceleration unit
+   */
+  @SuppressWarnings("unchecked")
+  public static <D extends Unit> AccelerationUnit<D> combine(
+      VelocityUnit<D> velocity, TimeUnit period) {
+    return cache.combine(velocity, period);
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/Angle.java

@@ -1,32 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.units;
-
-/**
- * Unit of angular dimension.
- *
- * <p>This is the base type for units of angular dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Angle&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Degrees} and {@link Units#Radians}) can be found in the
- * {@link Units} class.
- */
-// technically, angles are unitless dimensions
-// eg Mass * Distance * Velocity<Angle> is equivalent to (Mass * Distance) / Time - otherwise known
-// as Power - in other words, Velocity<Angle> is /actually/ Frequency
-public class Angle extends Unit<Angle> {
-  Angle(Angle baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Angle(
-      Angle baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-}

wpiunits/src/main/java/edu/wpi/first/units/AngleUnit.java

@@ -0,0 +1,93 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.Angle;
+import edu.wpi.first.units.measure.MutAngle;
+
+/**
+ * Unit of angular dimension.
+ *
+ * <p>This is the base type for units of angular dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;AngleUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Degrees} and {@link Units#Radians}) can be found in the
+ * {@link Units} class.
+ */
+// technically, angles are unitless dimensions
+// eg MassUnit * DistanceUnit * VelocityUnit<AngleUnit> is equivalent to (MassUnit * DistanceUnit) /
+// TimeUnit - otherwise known
+// as PowerUnit - in other words, VelocityUnit<AngleUnit> is /actually/ Frequency
+public final class AngleUnit extends Unit {
+  AngleUnit(AngleUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  AngleUnit(
+      AngleUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public AngleUnit getBaseUnit() {
+    return (AngleUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public Angle of(double magnitude) {
+    return Angle.ofRelativeUnits(magnitude, this);
+  }
+
+  @Override
+  public Angle ofBaseUnits(double baseUnitMagnitude) {
+    return Angle.ofBaseUnits(baseUnitMagnitude, this);
+  }
+
+  @Override
+  public MutAngle mutable(double initialMagnitude) {
+    return new MutAngle(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  @Override
+  public AngularVelocityUnit per(TimeUnit period) {
+    return AngularVelocityUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<AngleUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another angle unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other angle unit
+   * @param otherUnit the other angle unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, AngleUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  @Override
+  public Angle zero() {
+    return (Angle) super.zero();
+  }
+
+  @Override
+  public Angle one() {
+    return (Angle) super.one();
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/AngularAccelerationUnit.java

@@ -0,0 +1,102 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.AngularAcceleration;
+import edu.wpi.first.units.measure.ImmutableAngularAcceleration;
+import edu.wpi.first.units.measure.MutAngularAcceleration;
+
+/** A unit of angular acceleration, such as {@link Units#RadiansPerSecondPerSecond}. */
+public final class AngularAccelerationUnit extends PerUnit<AngularVelocityUnit, TimeUnit> {
+  private static final CombinatoryUnitCache<AngularVelocityUnit, TimeUnit, AngularAccelerationUnit>
+      cache = new CombinatoryUnitCache<>(AngularAccelerationUnit::new);
+
+  AngularAccelerationUnit(AngularVelocityUnit velocity, TimeUnit period) {
+    super(
+        velocity.isBaseUnit() && period.isBaseUnit()
+            ? null
+            : combine(velocity.getBaseUnit(), period.getBaseUnit()),
+        velocity,
+        period);
+  }
+
+  AngularAccelerationUnit(
+      AngularAccelerationUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines an angular velocity and time period unit into an angular acceleration.
+   *
+   * @param velocity the unit of velocity
+   * @param period the unit of time
+   * @return the combined angular acceleration unit
+   */
+  public static AngularAccelerationUnit combine(AngularVelocityUnit velocity, TimeUnit period) {
+    return cache.combine(velocity, period);
+  }
+
+  @Override
+  public AngularAccelerationUnit getBaseUnit() {
+    return (AngularAccelerationUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public AngularAcceleration of(double magnitude) {
+    return new ImmutableAngularAcceleration(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public AngularAcceleration ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableAngularAcceleration(
+        fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public AngularAcceleration zero() {
+    return (AngularAcceleration) super.zero();
+  }
+
+  @Override
+  public AngularAcceleration one() {
+    return (AngularAcceleration) super.one();
+  }
+
+  @Override
+  public MutAngularAcceleration mutable(double initialMagnitude) {
+    return new MutAngularAcceleration(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  @Override
+  public VelocityUnit<AngularAccelerationUnit> per(TimeUnit time) {
+    return VelocityUnit.combine(this, time);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<AngularAccelerationUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, AngularAccelerationUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/AngularMomentumUnit.java

@@ -0,0 +1,114 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.AngularMomentum;
+import edu.wpi.first.units.measure.ImmutableAngularMomentum;
+import edu.wpi.first.units.measure.MutAngularMomentum;
+
+/**
+ * A unit of angular momentum, modeled as linear momentum of an object rotating some distance away
+ * from the axis of rotation.
+ */
+public final class AngularMomentumUnit extends MultUnit<LinearMomentumUnit, DistanceUnit> {
+  private static final CombinatoryUnitCache<LinearMomentumUnit, DistanceUnit, AngularMomentumUnit>
+      cache = new CombinatoryUnitCache<>(AngularMomentumUnit::new);
+
+  AngularMomentumUnit(LinearMomentumUnit momentumUnit, DistanceUnit distanceUnit) {
+    super(
+        momentumUnit.isBaseUnit() && distanceUnit.isBaseUnit()
+            ? null
+            : combine(momentumUnit.getBaseUnit(), distanceUnit.getBaseUnit()),
+        momentumUnit,
+        distanceUnit);
+  }
+
+  AngularMomentumUnit(
+      AngularMomentumUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a linear momentum and distance to create a unit of angular momentum.
+   *
+   * @param linear the linear momentum unit
+   * @param distance the unit of distance from the axis of rotation
+   * @return the combined angular momentum unit
+   */
+  public static AngularMomentumUnit combine(LinearMomentumUnit linear, DistanceUnit distance) {
+    return cache.combine(linear, distance);
+  }
+
+  @Override
+  public AngularMomentumUnit getBaseUnit() {
+    return (AngularMomentumUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public AngularMomentum of(double magnitude) {
+    return new ImmutableAngularMomentum(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public AngularMomentum ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableAngularMomentum(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public AngularMomentum zero() {
+    return (AngularMomentum) super.zero();
+  }
+
+  @Override
+  public AngularMomentum one() {
+    return (AngularMomentum) super.one();
+  }
+
+  @Override
+  public MutAngularMomentum mutable(double magnitude) {
+    return new MutAngularMomentum(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public VelocityUnit<AngularMomentumUnit> per(TimeUnit time) {
+    return VelocityUnit.combine(this, time);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<AngularMomentumUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, AngularMomentumUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Multiplies this angular momentum by an angular velocity to yield a unit of moment of inertia.
+   *
+   * @param omega the unit of angular velocity
+   * @return the moment of inertia unit
+   */
+  public MomentOfInertiaUnit mult(AngularVelocityUnit omega) {
+    return MomentOfInertiaUnit.combine(this, omega);
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/AngularVelocityUnit.java

@@ -0,0 +1,101 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.AngularVelocity;
+import edu.wpi.first.units.measure.ImmutableAngularVelocity;
+import edu.wpi.first.units.measure.MutAngularVelocity;
+
+/** A unit of angular velocity like {@link Units#RadiansPerSecond}. */
+public final class AngularVelocityUnit extends PerUnit<AngleUnit, TimeUnit> {
+  private static final CombinatoryUnitCache<AngleUnit, TimeUnit, AngularVelocityUnit> cache =
+      new CombinatoryUnitCache<>(AngularVelocityUnit::new);
+
+  AngularVelocityUnit(AngleUnit numerator, TimeUnit denominator) {
+    super(
+        numerator.isBaseUnit() && denominator.isBaseUnit()
+            ? null
+            : combine(numerator.getBaseUnit(), denominator.getBaseUnit()),
+        numerator,
+        denominator);
+  }
+
+  AngularVelocityUnit(
+      AngularVelocityUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines an angle unit and a period of time into a unit of angular velocity.
+   *
+   * @param angle the unit of the changing angle
+   * @param time the period of the changing angle
+   * @return the combined angular velocity unit
+   */
+  public static AngularVelocityUnit combine(AngleUnit angle, TimeUnit time) {
+    return cache.combine(angle, time);
+  }
+
+  @Override
+  public AngularVelocityUnit getBaseUnit() {
+    return (AngularVelocityUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public AngularVelocity of(double magnitude) {
+    return new ImmutableAngularVelocity(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public AngularVelocity ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableAngularVelocity(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public AngularVelocity zero() {
+    return (AngularVelocity) super.zero();
+  }
+
+  @Override
+  public AngularVelocity one() {
+    return (AngularVelocity) super.one();
+  }
+
+  @Override
+  public MutAngularVelocity mutable(double initialMagnitude) {
+    return new MutAngularVelocity(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  @Override
+  public AngularAccelerationUnit per(TimeUnit period) {
+    return AngularAccelerationUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<AngularVelocityUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, AngularVelocityUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/BaseUnits.java

@@ -11,33 +11,30 @@ public final class BaseUnits {
   }
 
   /** The standard unit of distance, meters. */
-  public static final Distance Distance = new Distance(null, 1, "Meter", "m");
+  public static final DistanceUnit DistanceUnit = new DistanceUnit(null, 1, "Meter", "m");
 
   /** The standard unit of time, seconds. */
-  public static final Time Time = new Time(null, 1, "Second", "s");
+  public static final TimeUnit TimeUnit = new TimeUnit(null, 1, "Second", "s");
 
   /** The standard unit of mass, kilograms. */
-  public static final Mass Mass = new Mass(null, 1, "Kilogram", "Kg");
+  public static final MassUnit MassUnit = new MassUnit(null, 1, "Kilogram", "Kg");
 
   /** The standard unit of angles, radians. */
-  public static final Angle Angle = new Angle(null, 1, "Radian", "rad");
+  public static final AngleUnit AngleUnit = new AngleUnit(null, 1, "Radian", "rad");
 
   /** The standard "unitless" unit. */
-  public static final Dimensionless Value = new Dimensionless(null, 1, "<?>", "<?>");
+  public static final DimensionlessUnit Value = new DimensionlessUnit(null, 1, "<?>", "<?>");
 
   /** The standard unit of voltage, volts. */
-  public static final Voltage Voltage = new Voltage(null, 1, "Volt", "V");
+  public static final VoltageUnit VoltageUnit = new VoltageUnit(null, 1, "Volt", "V");
 
   /** The standard unit of electric current, amperes. */
-  public static final Current Current = new Current(null, 1, "Amp", "A");
+  public static final CurrentUnit CurrentUnit = new CurrentUnit(null, 1, "Amp", "A");
 
   /** The standard unit of energy, joules. */
-  public static final Energy Energy = new Energy(null, 1, "Joule", "J");
-
-  /** The standard unit of power, watts. */
-  public static final Power Power = new Power(null, 1, "Watt", "W");
+  public static final EnergyUnit EnergyUnit = new EnergyUnit(null, 1, "Joule", "J");
 
   /** The standard unit of temperature, kelvin. */
-  public static final Temperature Temperature =
-      new Temperature(null, x -> x, x -> x, "Kelvin", "K");
+  public static final TemperatureUnit TemperatureUnit =
+      new TemperatureUnit(null, x -> x, x -> x, "Kelvin", "K");
 }

wpiunits/src/main/java/edu/wpi/first/units/CombinatoryUnitCache.java

@@ -0,0 +1,60 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.collections.LongToObjectHashMap;
+import java.util.Objects;
+import java.util.function.BiFunction;
+
+/**
+ * A helper class for creating and caching combined unit objects. This helps to reduce unnecessary
+ * object allocation by reusing already-created units.
+ *
+ * @param <A> the type of the first unit to be combined
+ * @param <B> the type of the second unit to be combined
+ * @param <Out> the type of the combinatorial unit
+ */
+public final class CombinatoryUnitCache<A extends Unit, B extends Unit, Out extends Unit> {
+  /**
+   * Keep a cache of created instances so expressions like Volts.per(Meter) don't do any allocations
+   * after the first.
+   */
+  private final LongToObjectHashMap<Out> m_cache = new LongToObjectHashMap<>();
+
+  private final BiFunction<? super A, ? super B, ? extends Out> m_constructor;
+
+  /**
+   * Creates a new combinatory unit cache. The cache is initially empty and is not shared across
+   * instances.
+   *
+   * @param constructor the constructor function to use to create new combined units
+   */
+  public CombinatoryUnitCache(BiFunction<? super A, ? super B, ? extends Out> constructor) {
+    this.m_constructor =
+        Objects.requireNonNull(constructor, "Cache unit constructor must be provided");
+  }
+
+  /**
+   * Combines two units together and returns the result. The resulting units are cached and will be
+   * returned on successive calls to avoid allocating many duplicate objects. The combination output
+   * type is determined by the factory function passed into the cache's constructor.
+   *
+   * @param a the first unit
+   * @param b the second unit
+   * @return the combined unit
+   */
+  public Out combine(A a, B b) {
+    final long key = ((long) a.hashCode()) << 32L | (b.hashCode() & 0xFFFFFFFFL);
+
+    var existing = m_cache.get(key);
+    if (existing != null) {
+      return existing;
+    }
+
+    var newUnit = m_constructor.apply(a, b);
+    m_cache.put(key, newUnit);
+    return newUnit;
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/Current.java

@@ -1,46 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.units;
-
-import static edu.wpi.first.units.Units.Watts;
-
-/**
- * Unit of electric current dimension.
- *
- * <p>This is the base type for units of current dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Current&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Amps} and {@link Units#Milliamps}) can be found in the
- * {@link Units} class.
- */
-public class Current extends Unit<Current> {
-  Current(Current baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Current(
-      Current baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-
-  /**
-   * Constructs a unit of power equivalent to this unit of electrical current multiplied by another
-   * unit of voltage. For example, {@code Amps.times(Volts)} will return a unit of power equivalent
-   * to one Watt; {@code Amps.times(Millivolts)} will return a unit of power equivalent to a
-   * milliwatt, and so on.
-   *
-   * @param voltage the voltage unit to multiply by
-   * @param name the name of the resulting unit of power
-   * @param symbol the symbol used to represent the unit of power
-   * @return the power unit
-   */
-  public Power times(Unit<Voltage> voltage, String name, String symbol) {
-    return new Power(Watts, this.toBaseUnits(1) * voltage.toBaseUnits(1), name, symbol);
-  }
-}

wpiunits/src/main/java/edu/wpi/first/units/CurrentUnit.java

@@ -0,0 +1,105 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.Current;
+import edu.wpi.first.units.measure.ImmutableCurrent;
+import edu.wpi.first.units.measure.MutCurrent;
+
+/**
+ * Unit of electric current dimension.
+ *
+ * <p>This is the base type for units of current dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;CurrentUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Amps} and {@link Units#Milliamps}) can be found in the
+ * {@link Units} class.
+ */
+public final class CurrentUnit extends Unit {
+  CurrentUnit(CurrentUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  CurrentUnit(
+      CurrentUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public CurrentUnit getBaseUnit() {
+    return (CurrentUnit) super.getBaseUnit();
+  }
+
+  /**
+   * Constructs a unit of power equivalent to this unit of electrical current multiplied by another
+   * unit of voltage. For example, {@code Amps.times(Volts)} will return a unit of power equivalent
+   * to one Watt; {@code Amps.times(Millivolts)} will return a unit of power equivalent to a
+   * milliwatt, and so on.
+   *
+   * @param voltage the voltage unit to multiply by
+   * @param name the name of the resulting unit of power
+   * @param symbol the symbol used to represent the unit of power
+   * @return the power unit
+   */
+  public PowerUnit mult(VoltageUnit voltage, String name, String symbol) {
+    return Units.derive(PowerUnit.combine(voltage, this)).named(name).symbol(symbol).make();
+  }
+
+  @Override
+  public Current of(double magnitude) {
+    return new ImmutableCurrent(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Current ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableCurrent(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Current zero() {
+    return (Current) super.zero();
+  }
+
+  @Override
+  public Current one() {
+    return (Current) super.one();
+  }
+
+  @Override
+  public MutCurrent mutable(double initialMagnitude) {
+    return new MutCurrent(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  @Override
+  public VelocityUnit<CurrentUnit> per(TimeUnit time) {
+    return VelocityUnit.combine(this, time);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<CurrentUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another current unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other current unit
+   * @param otherUnit the other current unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, CurrentUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/Dimensionless.java

@@ -1,30 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.units;
-
-/**
- * A type of unit that corresponds to raw values and not any physical dimension, such as percentage.
- */
-public class Dimensionless extends Unit<Dimensionless> {
-  /**
-   * Creates a new unit with the given name and multiplier to the base unit.
-   *
-   * @param baseUnitEquivalent the multiplier to convert this unit to the base unit of this type.
-   * @param name the name of the unit
-   * @param symbol the symbol of the unit
-   */
-  Dimensionless(Dimensionless baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Dimensionless(
-      Dimensionless baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-}

wpiunits/src/main/java/edu/wpi/first/units/DimensionlessUnit.java

@@ -0,0 +1,99 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.Dimensionless;
+import edu.wpi.first.units.measure.ImmutableDimensionless;
+import edu.wpi.first.units.measure.MutDimensionless;
+
+/**
+ * A type of unit that corresponds to raw values and not any physical dimension, such as percentage.
+ */
+public final class DimensionlessUnit extends Unit {
+  /**
+   * Creates a new unit with the given name and multiplier to the base unit.
+   *
+   * @param baseUnitEquivalent the multiplier to convert this unit to the base unit of this type.
+   * @param name the name of the unit
+   * @param symbol the symbol of the unit
+   */
+  DimensionlessUnit(
+      DimensionlessUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  DimensionlessUnit(
+      DimensionlessUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public DimensionlessUnit getBaseUnit() {
+    return (DimensionlessUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public Dimensionless of(double magnitude) {
+    return new ImmutableDimensionless(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Dimensionless ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableDimensionless(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Dimensionless zero() {
+    return (Dimensionless) super.zero();
+  }
+
+  @Override
+  public Dimensionless one() {
+    return (Dimensionless) super.one();
+  }
+
+  @Override
+  public MutDimensionless mutable(double initialMagnitude) {
+    return new MutDimensionless(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  /**
+   * Converts a measurement value in terms of another dimensionless unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other dimensionless unit
+   * @param otherUnit the other dimensionless unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, DimensionlessUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Creates a frequency unit as the ratio of this dimensionless unit to the period of time in which
+   * a single cycle is made.
+   *
+   * @param period the cycle period
+   * @return the combined frequency unit
+   */
+  @Override
+  public FrequencyUnit per(TimeUnit period) {
+    return FrequencyUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<DimensionlessUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/Distance.java

@@ -1,29 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.units;
-
-/**
- * Unit of linear dimension.
- *
- * <p>This is the base type for units of linear dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Distance&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Meters} and {@link Units#Inches}) can be found in the
- * {@link Units} class.
- */
-public class Distance extends Unit<Distance> {
-  Distance(Distance baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Distance(
-      Distance baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-}

wpiunits/src/main/java/edu/wpi/first/units/DistanceUnit.java

@@ -0,0 +1,102 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.Distance;
+import edu.wpi.first.units.measure.ImmutableDistance;
+import edu.wpi.first.units.measure.MutDistance;
+
+/**
+ * Unit of linear dimension.
+ *
+ * <p>This is the base type for units of linear dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;DistanceUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Meters} and {@link Units#Inches}) can be found in the
+ * {@link Units} class.
+ */
+public final class DistanceUnit extends Unit {
+  DistanceUnit(DistanceUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  DistanceUnit(
+      DistanceUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public DistanceUnit getBaseUnit() {
+    return (DistanceUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public LinearVelocityUnit per(TimeUnit period) {
+    return LinearVelocityUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<DistanceUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another distance unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other distance unit
+   * @param otherUnit the other distance unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, DistanceUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  @Override
+  public Distance of(double magnitude) {
+    return new ImmutableDistance(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Distance ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableDistance(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Distance zero() {
+    return (Distance) super.zero();
+  }
+
+  @Override
+  public Distance one() {
+    return (Distance) super.one();
+  }
+
+  @Override
+  public MutDistance mutable(double initialMagnitude) {
+    return new MutDistance(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  /**
+   * Multiplies this distance unit by a unit of force to create a unit of torque.
+   *
+   * @param force the unit of force
+   * @return the combined torque unit
+   */
+  public TorqueUnit multAsTorque(ForceUnit force) {
+    return TorqueUnit.combine(this, force);
+  }
+
+  // TODO: Add a multAsEnergy equivalent
+}

wpiunits/src/main/java/edu/wpi/first/units/Energy.java

@@ -1,29 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.units;
-
-/**
- * Unit of energy dimension.
- *
- * <p>This is the base type for units of energy dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Energy&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Joules} and {@link Units#Kilojoules}) can be found in the
- * {@link Units} class.
- */
-public class Energy extends Unit<Energy> {
-  Energy(
-      Energy baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-
-  Energy(Energy baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-}

wpiunits/src/main/java/edu/wpi/first/units/EnergyUnit.java

@@ -0,0 +1,96 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.Energy;
+import edu.wpi.first.units.measure.ImmutableEnergy;
+import edu.wpi.first.units.measure.MutEnergy;
+
+/**
+ * Unit of energy dimension.
+ *
+ * <p>This is the base type for units of energy dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;EnergyUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Joules} and {@link Units#Kilojoules}) can be found in the
+ * {@link Units} class.
+ */
+public final class EnergyUnit extends Unit {
+  EnergyUnit(
+      EnergyUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  EnergyUnit(EnergyUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  @Override
+  public EnergyUnit getBaseUnit() {
+    return (EnergyUnit) super.getBaseUnit();
+  }
+
+  /**
+   * Combines this unit of energy with a unit of time to create a unit of power.
+   *
+   * @param period the period of the change in energy
+   * @return the combined unit of power
+   */
+  @Override
+  public PowerUnit per(TimeUnit period) {
+    return PowerUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<EnergyUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, EnergyUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  @Override
+  public Energy of(double magnitude) {
+    return new ImmutableEnergy(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Energy ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableEnergy(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Energy zero() {
+    return (Energy) super.zero();
+  }
+
+  @Override
+  public Energy one() {
+    return (Energy) super.one();
+  }
+
+  @Override
+  public MutEnergy mutable(double initialMagnitude) {
+    return new MutEnergy(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/ForceUnit.java

@@ -0,0 +1,113 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.Force;
+import edu.wpi.first.units.measure.ImmutableForce;
+import edu.wpi.first.units.measure.MutForce;
+
+/** A unit of force like {@link Units#Newtons}. */
+public final class ForceUnit extends MultUnit<MassUnit, LinearAccelerationUnit> {
+  private static final CombinatoryUnitCache<MassUnit, LinearAccelerationUnit, ForceUnit> cache =
+      new CombinatoryUnitCache<>(ForceUnit::new);
+
+  ForceUnit(MassUnit mass, LinearAccelerationUnit acceleration) {
+    super(
+        mass.isBaseUnit() && acceleration.isBaseUnit()
+            ? null
+            : combine(mass.getBaseUnit(), acceleration.getBaseUnit()),
+        mass,
+        acceleration);
+  }
+
+  ForceUnit(
+      ForceUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a mass and (linear) acceleration to form a unit of force.
+   *
+   * @param mass the unit of mass
+   * @param acceleration the unit of acceleration
+   * @return the combined unit of force
+   */
+  public static ForceUnit combine(MassUnit mass, LinearAccelerationUnit acceleration) {
+    return cache.combine(mass, acceleration);
+  }
+
+  @Override
+  public ForceUnit getBaseUnit() {
+    return (ForceUnit) super.getBaseUnit();
+  }
+
+  /**
+   * Multiplies this force unit by a unit of distance to create a unit of torque.
+   *
+   * @param distance the unit of distance
+   * @return the combined torque unit
+   */
+  public TorqueUnit multAsTorque(DistanceUnit distance) {
+    return TorqueUnit.combine(distance, this);
+  }
+
+  // TODO: Add a multAsEnergy equivalent
+
+  @Override
+  public Force of(double magnitude) {
+    return new ImmutableForce(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Force ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableForce(toBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Force zero() {
+    return (Force) super.zero();
+  }
+
+  @Override
+  public Force one() {
+    return (Force) super.one();
+  }
+
+  @Override
+  public MutForce mutable(double initialMagnitude) {
+    return new MutForce(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  @Override
+  public VelocityUnit<ForceUnit> per(TimeUnit time) {
+    return VelocityUnit.combine(this, time);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<ForceUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, ForceUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/FrequencyUnit.java

@@ -0,0 +1,114 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import static edu.wpi.first.units.Units.Value;
+
+import edu.wpi.first.units.measure.Frequency;
+import edu.wpi.first.units.measure.ImmutableFrequency;
+import edu.wpi.first.units.measure.MutFrequency;
+
+/** A unit of frequency like {@link edu.wpi.first.units.Units#Hertz}. */
+public final class FrequencyUnit extends PerUnit<DimensionlessUnit, TimeUnit> {
+  private static final CombinatoryUnitCache<DimensionlessUnit, TimeUnit, FrequencyUnit> cache =
+      new CombinatoryUnitCache<>(FrequencyUnit::new);
+
+  FrequencyUnit(DimensionlessUnit numerator, TimeUnit denominator) {
+    super(
+        numerator.isBaseUnit() && denominator.isBaseUnit()
+            ? null
+            : combine(numerator.getBaseUnit(), denominator.getBaseUnit()),
+        numerator,
+        denominator);
+  }
+
+  FrequencyUnit(
+      FrequencyUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a dimensionless unit and a cycle period to create a frequency.
+   *
+   * @param dim the dimensionless unit
+   * @param period the unit of time
+   * @return the combined unit of frequency
+   */
+  public static FrequencyUnit combine(DimensionlessUnit dim, TimeUnit period) {
+    return cache.combine(dim, period);
+  }
+
+  @Override
+  public FrequencyUnit getBaseUnit() {
+    return (FrequencyUnit) super.getBaseUnit();
+  }
+
+  /**
+   * Inverts a unit of time to get its corresponding frequency (as if the unit of time is the period
+   * of the frequency).
+   *
+   * @param time period of the associated frequency
+   * @return the frequency associated with the period
+   */
+  public static FrequencyUnit inverse(TimeUnit time) {
+    return combine(Value, time);
+  }
+
+  @Override
+  public Frequency of(double magnitude) {
+    return new ImmutableFrequency(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Frequency ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableFrequency(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Frequency zero() {
+    return (Frequency) super.zero();
+  }
+
+  @Override
+  public Frequency one() {
+    return (Frequency) super.one();
+  }
+
+  @Override
+  public MutFrequency mutable(double initialMagnitude) {
+    return new MutFrequency(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  @Override
+  public VelocityUnit<FrequencyUnit> per(TimeUnit time) {
+    return VelocityUnit.combine(this, time);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<FrequencyUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, FrequencyUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/ImmutableMeasure.java

@@ -4,7 +4,8 @@
 
 package edu.wpi.first.units;
 
-import java.util.Objects;
+import edu.wpi.first.units.measure.Dimensionless;
+import edu.wpi.first.units.mutable.GenericMutableMeasureImpl;
 
 /**
  * A measure holds the magnitude and unit of some dimension, such as distance, time, or speed. An
@@ -12,28 +13,13 @@ import java.util.Objects;
  * situations and gives compile-time safety. Two measures with the same <i>unit</i> and
  * <i>magnitude</i> are effectively equivalent objects.
  *
+ * @param magnitude the magnitude of the measure in terms of its unit
+ * @param baseUnitMagnitude the magnitude of the measure in terms of its base unit
+ * @param unit the unit of the measurement
  * @param <U> the unit type of the measure
  */
-public class ImmutableMeasure<U extends Unit<U>> implements Measure<U> {
-  private final double m_magnitude;
-  private final double m_baseUnitMagnitude;
-  private final U m_unit;
-
-  /**
-   * Creates a new immutable measure instance. This shouldn't be used directly; prefer one of the
-   * factory methods instead.
-   *
-   * @param magnitude the magnitude of this measure
-   * @param unit the unit of this measure.
-   */
-  @SuppressWarnings("unchecked")
-  ImmutableMeasure(double magnitude, double baseUnitMagnitude, Unit<U> unit) {
-    Objects.requireNonNull(unit, "Unit cannot be null");
-    m_magnitude = magnitude;
-    m_baseUnitMagnitude = baseUnitMagnitude;
-    m_unit = (U) unit;
-  }
-
+public record ImmutableMeasure<U extends Unit>(double magnitude, double baseUnitMagnitude, U unit)
+    implements Measure<U> {
   /**
    * Creates a new measure in the given unit with a magnitude equal to the given one in base units.
    *
@@ -42,8 +28,7 @@ public class ImmutableMeasure<U extends Unit<U>> implements Measure<U> {
    * @param unit the unit of measure
    * @return a new measure
    */
-  public static <U extends Unit<U>> ImmutableMeasure<U> ofBaseUnits(
-      double baseUnitMagnitude, Unit<U> unit) {
+  public static <U extends Unit> ImmutableMeasure<U> ofBaseUnits(double baseUnitMagnitude, U unit) {
     return new ImmutableMeasure<>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
@@ -55,51 +40,53 @@ public class ImmutableMeasure<U extends Unit<U>> implements Measure<U> {
    * @param unit the unit of measure
    * @return a new measure
    */
-  public static <U extends Unit<U>> ImmutableMeasure<U> ofRelativeUnits(
-      double relativeMagnitude, Unit<U> unit) {
+  public static <U extends Unit> ImmutableMeasure<U> ofRelativeUnits(
+      double relativeMagnitude, U unit) {
     return new ImmutableMeasure<>(relativeMagnitude, unit.toBaseUnits(relativeMagnitude), unit);
   }
 
-  /** Gets the unitless magnitude of this measure. */
-  @Override
-  public double magnitude() {
-    return m_magnitude;
-  }
-
-  @Override
-  public double baseUnitMagnitude() {
-    return m_baseUnitMagnitude;
-  }
-
-  /** Gets the units of this measure. */
-  @Override
-  public U unit() {
-    return m_unit;
-  }
-
-  /**
-   * Checks for <i>object equality</i>. To check if two measures are <i>equivalent</i>, use {@link
-   * #isEquivalent(Measure) isEquivalent}.
-   */
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> that
-        && Objects.equals(m_unit, that.unit())
-        && m_baseUnitMagnitude == that.baseUnitMagnitude();
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(m_magnitude, m_unit);
-  }
-
   @Override
   public Measure<U> copy() {
     return this; // already immutable, no need to allocate a new object
   }
 
   @Override
-  public String toString() {
-    return toShortString();
+  public MutableMeasure<U, ?, ?> mutableCopy() {
+    return new GenericMutableMeasureImpl<>(magnitude, baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Measure<U> unaryMinus() {
+    return ofBaseUnits(0 - baseUnitMagnitude, unit);
+  }
+
+  @Override
+  public Measure<U> plus(Measure<? extends U> other) {
+    return ofBaseUnits(baseUnitMagnitude + other.baseUnitMagnitude(), unit);
+  }
+
+  @Override
+  public Measure<U> minus(Measure<? extends U> other) {
+    return ofBaseUnits(baseUnitMagnitude - other.baseUnitMagnitude(), unit);
+  }
+
+  @Override
+  public Measure<U> times(double multiplier) {
+    return ofBaseUnits(baseUnitMagnitude * multiplier, unit);
+  }
+
+  @Override
+  public Measure<U> times(Dimensionless multiplier) {
+    return ofBaseUnits(baseUnitMagnitude * multiplier.baseUnitMagnitude(), unit);
+  }
+
+  @Override
+  public Measure<U> divide(double divisor) {
+    return ofBaseUnits(baseUnitMagnitude / divisor, unit);
+  }
+
+  @Override
+  public Measure<U> divide(Dimensionless divisor) {
+    return ofBaseUnits(baseUnitMagnitude / divisor.baseUnitMagnitude(), unit);
   }
 }

wpiunits/src/main/java/edu/wpi/first/units/LinearAccelerationUnit.java

@@ -0,0 +1,125 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.ImmutableLinearAcceleration;
+import edu.wpi.first.units.measure.LinearAcceleration;
+import edu.wpi.first.units.measure.MutLinearAcceleration;
+
+/**
+ * A unit of linear acceleration like {@link edu.wpi.first.units.Units#MetersPerSecondPerSecond}.
+ */
+public final class LinearAccelerationUnit extends PerUnit<LinearVelocityUnit, TimeUnit> {
+  private static final CombinatoryUnitCache<LinearVelocityUnit, TimeUnit, LinearAccelerationUnit>
+      cache = new CombinatoryUnitCache<>(LinearAccelerationUnit::new);
+
+  LinearAccelerationUnit(LinearVelocityUnit numerator, TimeUnit denominator) {
+    super(
+        numerator.isBaseUnit() && denominator.isBaseUnit()
+            ? null
+            : combine(numerator.getBaseUnit(), denominator.getBaseUnit()),
+        numerator,
+        denominator);
+  }
+
+  LinearAccelerationUnit(
+      LinearAccelerationUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a linear velocity and time unit to form a unit of linear acceleration.
+   *
+   * @param velocity the unit of linear velocity
+   * @param period the unit of time
+   * @return the combined unit of linear acceleration
+   */
+  public static LinearAccelerationUnit combine(LinearVelocityUnit velocity, TimeUnit period) {
+    return cache.combine(velocity, period);
+  }
+
+  @Override
+  public LinearAccelerationUnit getBaseUnit() {
+    return (LinearAccelerationUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public LinearAcceleration of(double magnitude) {
+    return new ImmutableLinearAcceleration(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public LinearAcceleration ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableLinearAcceleration(
+        fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public LinearAcceleration zero() {
+    return (LinearAcceleration) super.zero();
+  }
+
+  @Override
+  public LinearAcceleration one() {
+    return (LinearAcceleration) super.one();
+  }
+
+  @Override
+  public MutLinearAcceleration mutable(double initialMagnitude) {
+    return new MutLinearAcceleration(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  @Override
+  public VelocityUnit<LinearAccelerationUnit> per(TimeUnit time) {
+    return VelocityUnit.combine(this, time);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<LinearAccelerationUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, LinearAccelerationUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Gets the unit of the changing velocity. This is equivalent to {@link #numerator()} and is left
+   * for historical purposes.
+   *
+   * @return the unit of the changing velocity
+   */
+  public LinearVelocityUnit getUnit() {
+    return numerator();
+  }
+
+  /**
+   * Gets the unit of the acceleration period (how long it takes for a measured velocity to change
+   * by one unit of velocity). This is equivalent to {@link #numerator()} and is left for historical
+   * purposes.
+   *
+   * @return the unit of the acceleration period
+   */
+  public TimeUnit getPeriod() {
+    return denominator();
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/LinearMomentumUnit.java

@@ -0,0 +1,111 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.ImmutableLinearMomentum;
+import edu.wpi.first.units.measure.LinearMomentum;
+import edu.wpi.first.units.measure.MutLinearMomentum;
+
+/** A unit of linear momentum like {@link edu.wpi.first.units.Units#KilogramMetersPerSecond}. */
+public final class LinearMomentumUnit extends MultUnit<MassUnit, LinearVelocityUnit> {
+  private static final CombinatoryUnitCache<MassUnit, LinearVelocityUnit, LinearMomentumUnit>
+      cache = new CombinatoryUnitCache<>(LinearMomentumUnit::new);
+
+  LinearMomentumUnit(MassUnit unit, LinearVelocityUnit linearVelocityUnit) {
+    super(
+        unit.isBaseUnit() && linearVelocityUnit.isBaseUnit()
+            ? null
+            : combine(unit.getBaseUnit(), linearVelocityUnit.getBaseUnit()),
+        unit,
+        linearVelocityUnit);
+  }
+
+  LinearMomentumUnit(
+      MultUnit<MassUnit, LinearVelocityUnit> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a mass and linear velocity unit to form a combined linear momentum unit.
+   *
+   * @param mass the unit of mass
+   * @param velocity the unit of velocity
+   * @return the combined unit of momentum
+   */
+  public static LinearMomentumUnit combine(MassUnit mass, LinearVelocityUnit velocity) {
+    return cache.combine(mass, velocity);
+  }
+
+  @Override
+  public LinearMomentumUnit getBaseUnit() {
+    return (LinearMomentumUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public LinearMomentum of(double magnitude) {
+    return new ImmutableLinearMomentum(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public LinearMomentum ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableLinearMomentum(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public LinearMomentum zero() {
+    return (LinearMomentum) super.zero();
+  }
+
+  @Override
+  public LinearMomentum one() {
+    return (LinearMomentum) super.one();
+  }
+
+  @Override
+  public MutLinearMomentum mutable(double initialMagnitude) {
+    return new MutLinearMomentum(initialMagnitude, toBaseUnits(initialMagnitude), this);
+  }
+
+  @Override
+  public VelocityUnit<LinearMomentumUnit> per(TimeUnit time) {
+    return VelocityUnit.combine(this, time);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<LinearMomentumUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, LinearMomentumUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Multiplies this unit by distance to form a unit of angular momentum.
+   *
+   * @param distance the unit of distance
+   * @return the combined unit of angular momentum
+   */
+  public AngularMomentumUnit mult(DistanceUnit distance) {
+    return AngularMomentumUnit.combine(this, distance);
+  }
+}

wpiunits/src/main/java/edu/wpi/first/units/LinearVelocityUnit.java

@@ -0,0 +1,107 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.units;
+
+import edu.wpi.first.units.measure.ImmutableLinearVelocity;
+import edu.wpi.first.units.measure.LinearVelocity;
+import edu.wpi.first.units.measure.MutLinearVelocity;
+
+/** A unit of linear velocity like {@link edu.wpi.first.units.Units#MetersPerSecond}. */
+public final class LinearVelocityUnit extends PerUnit<DistanceUnit, TimeUnit> {
+  private static final CombinatoryUnitCache<DistanceUnit, TimeUnit, LinearVelocityUnit> cache =
+      new CombinatoryUnitCache<>(LinearVelocityUnit::new);
+
+  LinearVelocityUnit(DistanceUnit unit, TimeUnit period) {
+    super(
+        unit.isBaseUnit() && period.isBaseUnit()
+            ? null
+            : combine(unit.getBaseUnit(), period.getBaseUnit()),
+        unit,
+        period);
+  }
+
+  LinearVelocityUnit(
+      PerUnit<DistanceUnit, TimeUnit> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a distance and time unit for form a combined unit of velocity.
+   *
+   * @param distance the unit of distance
+   * @param period the unit of time
+   * @return the combined velocity unit
+   */
+  public static LinearVelocityUnit combine(DistanceUnit distance, TimeUnit period) {
+    return cache.combine(distance, period);
+  }
+
+  @Override
+  public LinearVelocityUnit getBaseUnit() {
+    return (LinearVelocityUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public LinearVelocity of(double magnitude) {
+    return new ImmutableLinearVelocity(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public LinearVelocity ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableLinearVelocity(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public LinearVelocity zero() {
+    return (LinearVelocity) super.zero();
+  }
+
+  @Override
+  public LinearVelocity one() {
+    return (LinearVelocity) super.one();
+  }
+
+  @Override
+  public MutLinearVelocity mutable(double value) {
+    return new MutLinearVelocity(value, toBaseUnits(value), this);
+  }
+
+  /**
+   * Combines this velocity with a time period of change to form a unit of acceleration.
+   *
+   * @param period the period of change in the velocity
+   * @return the combined acceleration unit
+   */
+  @Override
+  public LinearAccelerationUnit per(TimeUnit period) {
+    return LinearAccelerationUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<LinearVelocityUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, LinearVelocityUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}