diff --git a/wpiunits/generate_units.py b/wpiunits/generate_units.py index 2aebf286c22..e07ae67599c 100755 --- a/wpiunits/generate_units.py +++ b/wpiunits/generate_units.py @@ -56,6 +56,10 @@ def output(outPath, outfn, contents): "Torque", "Velocity", "Voltage", + "VoltagePerAnglePerTime", + "VoltagePerAnglePerTimeSquared", + "VoltagePerDistancePerTime", + "VoltagePerDistancePerTimeSquared", ] # Configurations for all generated units @@ -73,8 +77,13 @@ def output(outPath, outfn, contents): }, "AngularAcceleration": { "base_unit": "RadiansPerSecondPerSecond", - "multiply": {"Time": "AngularVelocity"}, - "divide": {"Frequency": "AngularVelocity"}, + "multiply": { + "Time": "AngularVelocity", + "VoltagePerAnglePerTimeSquared": "Voltage", + }, + "divide": { + "Frequency": "AngularVelocity", + }, }, "AngularMomentum": { "base_unit": "KilogramMetersSquaredPerSecond", @@ -83,8 +92,14 @@ def output(outPath, outfn, contents): }, "AngularVelocity": { "base_unit": "RadiansPerSecond", - "multiply": {"Time": "Angle", "Frequency": "AngularAcceleration"}, - "divide": {"Time": "AngularAcceleration"}, + "multiply": { + "Time": "Angle", + "Frequency": "AngularAcceleration", + "VoltagePerAnglePerTime": "Voltage", + }, + "divide": { + "Time": "AngularAcceleration", + }, "extra": inspect.cleandoc( """ default Frequency asFrequency() { return Hertz.of(baseUnitMagnitude()); } @@ -115,6 +130,10 @@ def output(outPath, outfn, contents): "Time": "Time", "Torque": "Torque", "Voltage": "Voltage", + "VoltagePerAnglePerTime": "VoltagePerAnglePerTime", + "VoltagePerAnglePerTimeSquared": "VoltagePerAnglePerTimeSquared", + "VoltagePerDistancePerTime": "VoltagePerDistancePerTime", + "VoltagePerDistancePerTimeSquared": "VoltagePerDistancePerTimeSquared", }, "divide": { "Time": "Frequency", @@ -171,7 +190,10 @@ def output(outPath, outfn, contents): }, "LinearAcceleration": { "base_unit": "MetersPerSecondPerSecond", - "multiply": {"Time": "LinearVelocity"}, + "multiply": { + "Time": "LinearVelocity", + "VoltagePerDistancePerTimeSquared": "Voltage", + }, "divide": {"Frequency": "LinearVelocity"}, }, "LinearMomentum": { @@ -181,8 +203,14 @@ def output(outPath, outfn, contents): }, "LinearVelocity": { "base_unit": "MetersPerSecond", - "multiply": {"Time": "Distance", "Frequency": "LinearAcceleration"}, - "divide": {"Time": "LinearAcceleration"}, + "multiply": { + "Time": "Distance", + "Frequency": "LinearAcceleration", + "VoltagePerDistancePerTime": "Voltage", + }, + "divide": { + "Time": "LinearAcceleration", + }, }, "Mass": { "base_unit": "Kilograms", @@ -261,7 +289,40 @@ def output(outPath, outfn, contents): "multiply": {}, "divide": {}, }, - "Voltage": {"base_unit": "Volts", "multiply": {"Current": "Power"}, "divide": {}}, + "Voltage": { + "base_unit": "Volts", + "multiply": {"Current": "Power"}, + "divide": { + "VoltagePerAnglePerTime": "AngularVelocity", + "AngularVelocity": "VoltagePerAnglePerTime", + "VoltagePerAnglePerTimeSquared": "AngularAcceleration", + "AngularAcceleration": "VoltagePerAnglePerTimeSquared", + "VoltagePerDistancePerTime": "LinearVelocity", + "LinearVelocity": "VoltagePerDistancePerTime", + "VoltagePerDistancePerTimeSquared": "LinearAcceleration", + "LinearAcceleration": "VoltagePerDistancePerTimeSquared", + }, + }, + "VoltagePerAnglePerTime": { + "base_unit": "VoltsPerRadianPerSecond", + "multiply": {"AngularVelocity": "Voltage"}, + "divide": {}, + }, + "VoltagePerAnglePerTimeSquared": { + "base_unit": "VoltsPerRadianPerSecondSquared", + "multiply": {"AngularAcceleration": "Voltage"}, + "divide": {}, + }, + "VoltagePerDistancePerTime": { + "base_unit": "VoltsPerMeterPerSecond", + "multiply": {"LinearVelocity": "Voltage"}, + "divide": {}, + }, + "VoltagePerDistancePerTimeSquared": { + "base_unit": "VoltsPerMeterPerSecondSquared", + "multiply": {"LinearAcceleration": "Voltage"}, + "divide": {}, + }, } @@ -311,7 +372,6 @@ def mtou(measure_name): def main(): - dirname, _ = os.path.split(os.path.abspath(__file__)) env = Environment( diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java index f4ceb282439..de207062409 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java @@ -331,4 +331,48 @@ default Per, VoltageUnit> divide(Voltage divisor) { return (Per, VoltageUnit>) Measure.super.divide(divisor); } + + @Override + default Mult, VoltagePerAnglePerTimeUnit> times(VoltagePerAnglePerTime multiplier) { + return (Mult, VoltagePerAnglePerTimeUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerAnglePerTimeUnit> divide(VoltagePerAnglePerTime divisor) { + return (Per, VoltagePerAnglePerTimeUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerAnglePerTimeSquaredUnit> times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult, VoltagePerAnglePerTimeSquaredUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerAnglePerTimeSquaredUnit> divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per, VoltagePerAnglePerTimeSquaredUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerDistancePerTimeUnit> times(VoltagePerDistancePerTime multiplier) { + return (Mult, VoltagePerDistancePerTimeUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerDistancePerTimeUnit> divide(VoltagePerDistancePerTime divisor) { + return (Per, VoltagePerDistancePerTimeUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerDistancePerTimeSquaredUnit> times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult, VoltagePerDistancePerTimeSquaredUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerDistancePerTimeSquaredUnit> divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per, VoltagePerDistancePerTimeSquaredUnit>) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java index c182d48f3c1..9821b6a9ba0 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java index 44ff1c395b1..7661047b488 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Voltage times(VoltagePerAnglePerTimeSquared multiplier) { + return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java index 631ac45cafa..7b70c9fb355 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java index 5c017c5c8f1..92438c7bc33 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java @@ -330,5 +330,49 @@ default Mult times(Voltage multiplier) { default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + + @Override + default Voltage times(VoltagePerAnglePerTime multiplier) { + return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } default Frequency asFrequency() { return Hertz.of(baseUnitMagnitude()); } } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java index e7af53dfdac..f18f8ab976e 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java index 942f55d4155..ff0bd50048a 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default VoltagePerAnglePerTime times(VoltagePerAnglePerTime multiplier) { + return VoltsPerRadianPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default VoltagePerAnglePerTimeSquared times(VoltagePerAnglePerTimeSquared multiplier) { + return VoltsPerRadianPerSecondSquared.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default VoltagePerDistancePerTime times(VoltagePerDistancePerTime multiplier) { + return VoltsPerMeterPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default VoltagePerDistancePerTimeSquared times(VoltagePerDistancePerTimeSquared multiplier) { + return VoltsPerMeterPerSecondSquared.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java index f87106362ef..5cb781ef4c5 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java index d20f8f19622..a18de07a574 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java index 2f69f808b8b..f7d84d29117 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java index ebce2a9a31c..b0ceef48423 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java @@ -330,6 +330,50 @@ default Mult times(Voltage multiplier) { default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } /** Converts this frequency to the time period between cycles. */ default Time asPeriod() { return Seconds.of(1 / baseUnitMagnitude()); } } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerAnglePerTime.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerAnglePerTime.java new file mode 100644 index 00000000000..dc8e55617e2 --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerAnglePerTime.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 ImmutableVoltagePerAnglePerTime(double magnitude, double baseUnitMagnitude, VoltagePerAnglePerTimeUnit unit) implements VoltagePerAnglePerTime { + @Override + public VoltagePerAnglePerTime copy() { + return this; + } + + @Override + public String toString() { + return toShortString(); + } + + @Override + public boolean equals(Object o) { + return o instanceof Measure m && isEquivalent(m); + } +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerAnglePerTimeSquared.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerAnglePerTimeSquared.java new file mode 100644 index 00000000000..f922a6cfa9a --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerAnglePerTimeSquared.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 ImmutableVoltagePerAnglePerTimeSquared(double magnitude, double baseUnitMagnitude, VoltagePerAnglePerTimeSquaredUnit unit) implements VoltagePerAnglePerTimeSquared { + @Override + public VoltagePerAnglePerTimeSquared copy() { + return this; + } + + @Override + public String toString() { + return toShortString(); + } + + @Override + public boolean equals(Object o) { + return o instanceof Measure m && isEquivalent(m); + } +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerDistancePerTime.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerDistancePerTime.java new file mode 100644 index 00000000000..64c92fca7ee --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerDistancePerTime.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 ImmutableVoltagePerDistancePerTime(double magnitude, double baseUnitMagnitude, VoltagePerDistancePerTimeUnit unit) implements VoltagePerDistancePerTime { + @Override + public VoltagePerDistancePerTime copy() { + return this; + } + + @Override + public String toString() { + return toShortString(); + } + + @Override + public boolean equals(Object o) { + return o instanceof Measure m && isEquivalent(m); + } +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerDistancePerTimeSquared.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerDistancePerTimeSquared.java new file mode 100644 index 00000000000..096af6aaf61 --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltagePerDistancePerTimeSquared.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 ImmutableVoltagePerDistancePerTimeSquared(double magnitude, double baseUnitMagnitude, VoltagePerDistancePerTimeSquaredUnit unit) implements VoltagePerDistancePerTimeSquared { + @Override + public VoltagePerDistancePerTimeSquared copy() { + return this; + } + + @Override + public String toString() { + return toShortString(); + } + + @Override + public boolean equals(Object o) { + return o instanceof Measure m && isEquivalent(m); + } +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java index f595bcc33ff..36fd0674994 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Voltage times(VoltagePerDistancePerTimeSquared multiplier) { + return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java index 92177a9598c..231b2555a90 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java index 4f3d1c389de..b17e5b0de60 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Voltage times(VoltagePerDistancePerTime multiplier) { + return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java index 6046be68d45..d167793280a 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java index c56c6ba0015..f15b6d3ee1e 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java index 9ea6033054f..662cd12aba5 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java @@ -331,4 +331,48 @@ default Per, VoltageUnit> divide(Voltage divisor) { return (Per, VoltageUnit>) Measure.super.divide(divisor); } + + @Override + default Mult, VoltagePerAnglePerTimeUnit> times(VoltagePerAnglePerTime multiplier) { + return (Mult, VoltagePerAnglePerTimeUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerAnglePerTimeUnit> divide(VoltagePerAnglePerTime divisor) { + return (Per, VoltagePerAnglePerTimeUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerAnglePerTimeSquaredUnit> times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult, VoltagePerAnglePerTimeSquaredUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerAnglePerTimeSquaredUnit> divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per, VoltagePerAnglePerTimeSquaredUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerDistancePerTimeUnit> times(VoltagePerDistancePerTime multiplier) { + return (Mult, VoltagePerDistancePerTimeUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerDistancePerTimeUnit> divide(VoltagePerDistancePerTime divisor) { + return (Per, VoltagePerDistancePerTimeUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerDistancePerTimeSquaredUnit> times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult, VoltagePerDistancePerTimeSquaredUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerDistancePerTimeSquaredUnit> divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per, VoltagePerDistancePerTimeSquaredUnit>) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerAnglePerTime.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerAnglePerTime.java new file mode 100644 index 00000000000..97a43600d12 --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerAnglePerTime.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 MutVoltagePerAnglePerTime + extends MutableMeasureBase + implements VoltagePerAnglePerTime { + public MutVoltagePerAnglePerTime(double magnitude, double baseUnitMagnitude, VoltagePerAnglePerTimeUnit unit) { + super(magnitude, baseUnitMagnitude, unit); + } + + @Override + public VoltagePerAnglePerTime copy() { + return new ImmutableVoltagePerAnglePerTime(magnitude(), baseUnitMagnitude(), unit()); + } +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerAnglePerTimeSquared.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerAnglePerTimeSquared.java new file mode 100644 index 00000000000..30f4b3d5aa5 --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerAnglePerTimeSquared.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 MutVoltagePerAnglePerTimeSquared + extends MutableMeasureBase + implements VoltagePerAnglePerTimeSquared { + public MutVoltagePerAnglePerTimeSquared(double magnitude, double baseUnitMagnitude, VoltagePerAnglePerTimeSquaredUnit unit) { + super(magnitude, baseUnitMagnitude, unit); + } + + @Override + public VoltagePerAnglePerTimeSquared copy() { + return new ImmutableVoltagePerAnglePerTimeSquared(magnitude(), baseUnitMagnitude(), unit()); + } +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerDistancePerTime.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerDistancePerTime.java new file mode 100644 index 00000000000..14d594f8eee --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerDistancePerTime.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 MutVoltagePerDistancePerTime + extends MutableMeasureBase + implements VoltagePerDistancePerTime { + public MutVoltagePerDistancePerTime(double magnitude, double baseUnitMagnitude, VoltagePerDistancePerTimeUnit unit) { + super(magnitude, baseUnitMagnitude, unit); + } + + @Override + public VoltagePerDistancePerTime copy() { + return new ImmutableVoltagePerDistancePerTime(magnitude(), baseUnitMagnitude(), unit()); + } +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerDistancePerTimeSquared.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerDistancePerTimeSquared.java new file mode 100644 index 00000000000..9428b4386eb --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltagePerDistancePerTimeSquared.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 MutVoltagePerDistancePerTimeSquared + extends MutableMeasureBase + implements VoltagePerDistancePerTimeSquared { + public MutVoltagePerDistancePerTimeSquared(double magnitude, double baseUnitMagnitude, VoltagePerDistancePerTimeSquaredUnit unit) { + super(magnitude, baseUnitMagnitude, unit); + } + + @Override + public VoltagePerDistancePerTimeSquared copy() { + return new ImmutableVoltagePerDistancePerTimeSquared(magnitude(), baseUnitMagnitude(), unit()); + } +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java index b467e977a0e..b35c86ef856 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java @@ -330,6 +330,50 @@ default Mult, VoltageUnit> times(Voltage multiplier) default Per, VoltageUnit> divide(Voltage divisor) { return (Per, VoltageUnit>) Measure.super.divide(divisor); } + + + @Override + default Mult, VoltagePerAnglePerTimeUnit> times(VoltagePerAnglePerTime multiplier) { + return (Mult, VoltagePerAnglePerTimeUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerAnglePerTimeUnit> divide(VoltagePerAnglePerTime divisor) { + return (Per, VoltagePerAnglePerTimeUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerAnglePerTimeSquaredUnit> times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult, VoltagePerAnglePerTimeSquaredUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerAnglePerTimeSquaredUnit> divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per, VoltagePerAnglePerTimeSquaredUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerDistancePerTimeUnit> times(VoltagePerDistancePerTime multiplier) { + return (Mult, VoltagePerDistancePerTimeUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerDistancePerTimeUnit> divide(VoltagePerDistancePerTime divisor) { + return (Per, VoltagePerDistancePerTimeUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerDistancePerTimeSquaredUnit> times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult, VoltagePerDistancePerTimeSquaredUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerDistancePerTimeSquaredUnit> divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per, VoltagePerDistancePerTimeSquaredUnit>) Measure.super.divide(divisor); + } default Measure timesDivisor(Measure multiplier) { return (Measure) baseUnit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java index 054bfa785d4..84151b2dbd4 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java @@ -331,4 +331,48 @@ default Current divide(Voltage divisor) { return Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java index c9396f79223..8e9437dc94d 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java index aa4945c2a8d..ee33c011604 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java @@ -330,5 +330,49 @@ default Mult times(Voltage multiplier) { default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } default Frequency asFrequency() { return Hertz.of(1 / baseUnitMagnitude()); } } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java index ff1ccee5260..9d9e9c8cee2 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java @@ -331,4 +331,48 @@ default Per divide(Voltage divisor) { return (Per) Measure.super.divide(divisor); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java index bc1c9ce8c25..c85ffb2a82e 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java @@ -331,4 +331,48 @@ default Per, VoltageUnit> divide(Voltage divisor) { return (Per, VoltageUnit>) Measure.super.divide(divisor); } + + @Override + default Mult, VoltagePerAnglePerTimeUnit> times(VoltagePerAnglePerTime multiplier) { + return (Mult, VoltagePerAnglePerTimeUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerAnglePerTimeUnit> divide(VoltagePerAnglePerTime divisor) { + return (Per, VoltagePerAnglePerTimeUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerAnglePerTimeSquaredUnit> times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult, VoltagePerAnglePerTimeSquaredUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerAnglePerTimeSquaredUnit> divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per, VoltagePerAnglePerTimeSquaredUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerDistancePerTimeUnit> times(VoltagePerDistancePerTime multiplier) { + return (Mult, VoltagePerDistancePerTimeUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerDistancePerTimeUnit> divide(VoltagePerDistancePerTime divisor) { + return (Per, VoltagePerDistancePerTimeUnit>) Measure.super.divide(divisor); + } + + + @Override + default Mult, VoltagePerDistancePerTimeSquaredUnit> times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult, VoltagePerDistancePerTimeSquaredUnit>) Measure.super.times(multiplier); + } + + @Override + default Per, VoltagePerDistancePerTimeSquaredUnit> divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per, VoltagePerDistancePerTimeSquaredUnit>) Measure.super.divide(divisor); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java index 403bb7080ae..7f693d26127 100644 --- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java @@ -97,8 +97,8 @@ default Mult times(AngularAcceleration mul } @Override - default Per divide(AngularAcceleration divisor) { - return (Per) Measure.super.divide(divisor); + default VoltagePerAnglePerTimeSquared divide(AngularAcceleration divisor) { + return VoltsPerRadianPerSecondSquared.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); } @@ -119,8 +119,8 @@ default Mult times(AngularVelocity multiplier) } @Override - default Per divide(AngularVelocity divisor) { - return (Per) Measure.super.divide(divisor); + default VoltagePerAnglePerTime divide(AngularVelocity divisor) { + return VoltsPerRadianPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); } @@ -195,8 +195,8 @@ default Mult times(LinearAcceleration multi } @Override - default Per divide(LinearAcceleration divisor) { - return (Per) Measure.super.divide(divisor); + default VoltagePerDistancePerTimeSquared divide(LinearAcceleration divisor) { + return VoltsPerMeterPerSecondSquared.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); } @@ -217,8 +217,8 @@ default Mult times(LinearVelocity multiplier) { } @Override - default Per divide(LinearVelocity divisor) { - return (Per) Measure.super.divide(divisor); + default VoltagePerDistancePerTime divide(LinearVelocity divisor) { + return VoltsPerMeterPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); } @@ -331,4 +331,48 @@ default Dimensionless divide(Voltage divisor) { return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); } + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default AngularVelocity divide(VoltagePerAnglePerTime divisor) { + return RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default AngularAcceleration divide(VoltagePerAnglePerTimeSquared divisor) { + return RadiansPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default LinearVelocity divide(VoltagePerDistancePerTime divisor) { + return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default LinearAcceleration divide(VoltagePerDistancePerTimeSquared divisor) { + return MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + } diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerAnglePerTime.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerAnglePerTime.java new file mode 100644 index 00000000000..741df380839 --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerAnglePerTime.java @@ -0,0 +1,378 @@ +// 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 VoltagePerAnglePerTime extends Measure { + static VoltagePerAnglePerTime ofRelativeUnits(double magnitude, VoltagePerAnglePerTimeUnit unit) { + return new ImmutableVoltagePerAnglePerTime(magnitude, unit.toBaseUnits(magnitude), unit); + } + + static VoltagePerAnglePerTime ofBaseUnits(double baseUnitMagnitude, VoltagePerAnglePerTimeUnit unit) { + return new ImmutableVoltagePerAnglePerTime(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit); + } + + @Override + VoltagePerAnglePerTime copy(); + + @Override + default MutVoltagePerAnglePerTime mutableCopy() { + return new MutVoltagePerAnglePerTime(magnitude(), baseUnitMagnitude(), unit()); + } + + @Override + VoltagePerAnglePerTimeUnit unit(); + + @Override + default VoltagePerAnglePerTimeUnit baseUnit() { return (VoltagePerAnglePerTimeUnit) unit().getBaseUnit(); } + + @Override + default double in(VoltagePerAnglePerTimeUnit unit) { + return unit.fromBaseUnits(baseUnitMagnitude()); + } + + @Override + default VoltagePerAnglePerTime unaryMinus() { + return (VoltagePerAnglePerTime) unit().ofBaseUnits(0 - baseUnitMagnitude()); + } + + @Override + default VoltagePerAnglePerTime plus(Measure other) { + return (VoltagePerAnglePerTime) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude()); + } + + @Override + default VoltagePerAnglePerTime minus(Measure other) { + return (VoltagePerAnglePerTime) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude()); + } + + @Override + default VoltagePerAnglePerTime times(double multiplier) { + return (VoltagePerAnglePerTime) unit().ofBaseUnits(baseUnitMagnitude() * multiplier); + } + + @Override + default VoltagePerAnglePerTime divide(double divisor) { + return (VoltagePerAnglePerTime) unit().ofBaseUnits(baseUnitMagnitude() / divisor); + } + + @Override + default Velocity per(TimeUnit period) { + return divide(period.of(1)); + } + + + @Override + default Mult> times(Acceleration multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Acceleration divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Angle multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Angle divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(AngularAcceleration multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(AngularAcceleration divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(AngularMomentum multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(AngularMomentum divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Voltage times(AngularVelocity multiplier) { + return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(AngularVelocity divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Current multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Current divisor) { + return (Per) Measure.super.divide(divisor); + } + + @Override + default VoltagePerAnglePerTime divide(Dimensionless divisor) { + return (VoltagePerAnglePerTime) VoltsPerRadianPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + @Override + default VoltagePerAnglePerTime times(Dimensionless multiplier) { + return (VoltagePerAnglePerTime) VoltsPerRadianPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + + @Override + default Mult times(Distance multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Distance divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Energy multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Energy divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Force multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Force divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Frequency multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Frequency divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(LinearAcceleration multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(LinearAcceleration divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(LinearMomentum multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(LinearMomentum divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(LinearVelocity multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(LinearVelocity divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Mass multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Mass divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(MomentOfInertia multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(MomentOfInertia divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Mult multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Mult divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Per multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Per divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Power multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Power divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Temperature multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Temperature divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Time multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Velocity divide(Time divisor) { + return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + + @Override + default Mult times(Torque multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Torque divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Velocity multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Velocity divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Voltage multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Voltage divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Dimensionless divide(VoltagePerAnglePerTime divisor) { + return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerAnglePerTimeSquared.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerAnglePerTimeSquared.java new file mode 100644 index 00000000000..0a78c05ca7f --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerAnglePerTimeSquared.java @@ -0,0 +1,378 @@ +// 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 VoltagePerAnglePerTimeSquared extends Measure { + static VoltagePerAnglePerTimeSquared ofRelativeUnits(double magnitude, VoltagePerAnglePerTimeSquaredUnit unit) { + return new ImmutableVoltagePerAnglePerTimeSquared(magnitude, unit.toBaseUnits(magnitude), unit); + } + + static VoltagePerAnglePerTimeSquared ofBaseUnits(double baseUnitMagnitude, VoltagePerAnglePerTimeSquaredUnit unit) { + return new ImmutableVoltagePerAnglePerTimeSquared(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit); + } + + @Override + VoltagePerAnglePerTimeSquared copy(); + + @Override + default MutVoltagePerAnglePerTimeSquared mutableCopy() { + return new MutVoltagePerAnglePerTimeSquared(magnitude(), baseUnitMagnitude(), unit()); + } + + @Override + VoltagePerAnglePerTimeSquaredUnit unit(); + + @Override + default VoltagePerAnglePerTimeSquaredUnit baseUnit() { return (VoltagePerAnglePerTimeSquaredUnit) unit().getBaseUnit(); } + + @Override + default double in(VoltagePerAnglePerTimeSquaredUnit unit) { + return unit.fromBaseUnits(baseUnitMagnitude()); + } + + @Override + default VoltagePerAnglePerTimeSquared unaryMinus() { + return (VoltagePerAnglePerTimeSquared) unit().ofBaseUnits(0 - baseUnitMagnitude()); + } + + @Override + default VoltagePerAnglePerTimeSquared plus(Measure other) { + return (VoltagePerAnglePerTimeSquared) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude()); + } + + @Override + default VoltagePerAnglePerTimeSquared minus(Measure other) { + return (VoltagePerAnglePerTimeSquared) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude()); + } + + @Override + default VoltagePerAnglePerTimeSquared times(double multiplier) { + return (VoltagePerAnglePerTimeSquared) unit().ofBaseUnits(baseUnitMagnitude() * multiplier); + } + + @Override + default VoltagePerAnglePerTimeSquared divide(double divisor) { + return (VoltagePerAnglePerTimeSquared) unit().ofBaseUnits(baseUnitMagnitude() / divisor); + } + + @Override + default Velocity per(TimeUnit period) { + return divide(period.of(1)); + } + + + @Override + default Mult> times(Acceleration multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Acceleration divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Angle multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Angle divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Voltage times(AngularAcceleration multiplier) { + return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(AngularAcceleration divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(AngularMomentum multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(AngularMomentum divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(AngularVelocity multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(AngularVelocity divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Current multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Current divisor) { + return (Per) Measure.super.divide(divisor); + } + + @Override + default VoltagePerAnglePerTimeSquared divide(Dimensionless divisor) { + return (VoltagePerAnglePerTimeSquared) VoltsPerRadianPerSecondSquared.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + @Override + default VoltagePerAnglePerTimeSquared times(Dimensionless multiplier) { + return (VoltagePerAnglePerTimeSquared) VoltsPerRadianPerSecondSquared.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + + @Override + default Mult times(Distance multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Distance divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Energy multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Energy divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Force multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Force divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Frequency multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Frequency divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(LinearAcceleration multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(LinearAcceleration divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(LinearMomentum multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(LinearMomentum divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(LinearVelocity multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(LinearVelocity divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Mass multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Mass divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(MomentOfInertia multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(MomentOfInertia divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Mult multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Mult divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Per multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Per divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Power multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Power divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Temperature multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Temperature divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Time multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Velocity divide(Time divisor) { + return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + + @Override + default Mult times(Torque multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Torque divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Velocity multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Velocity divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Voltage multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Voltage divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Dimensionless divide(VoltagePerAnglePerTimeSquared divisor) { + return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerDistancePerTime.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerDistancePerTime.java new file mode 100644 index 00000000000..97f8aaac564 --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerDistancePerTime.java @@ -0,0 +1,378 @@ +// 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 VoltagePerDistancePerTime extends Measure { + static VoltagePerDistancePerTime ofRelativeUnits(double magnitude, VoltagePerDistancePerTimeUnit unit) { + return new ImmutableVoltagePerDistancePerTime(magnitude, unit.toBaseUnits(magnitude), unit); + } + + static VoltagePerDistancePerTime ofBaseUnits(double baseUnitMagnitude, VoltagePerDistancePerTimeUnit unit) { + return new ImmutableVoltagePerDistancePerTime(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit); + } + + @Override + VoltagePerDistancePerTime copy(); + + @Override + default MutVoltagePerDistancePerTime mutableCopy() { + return new MutVoltagePerDistancePerTime(magnitude(), baseUnitMagnitude(), unit()); + } + + @Override + VoltagePerDistancePerTimeUnit unit(); + + @Override + default VoltagePerDistancePerTimeUnit baseUnit() { return (VoltagePerDistancePerTimeUnit) unit().getBaseUnit(); } + + @Override + default double in(VoltagePerDistancePerTimeUnit unit) { + return unit.fromBaseUnits(baseUnitMagnitude()); + } + + @Override + default VoltagePerDistancePerTime unaryMinus() { + return (VoltagePerDistancePerTime) unit().ofBaseUnits(0 - baseUnitMagnitude()); + } + + @Override + default VoltagePerDistancePerTime plus(Measure other) { + return (VoltagePerDistancePerTime) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude()); + } + + @Override + default VoltagePerDistancePerTime minus(Measure other) { + return (VoltagePerDistancePerTime) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude()); + } + + @Override + default VoltagePerDistancePerTime times(double multiplier) { + return (VoltagePerDistancePerTime) unit().ofBaseUnits(baseUnitMagnitude() * multiplier); + } + + @Override + default VoltagePerDistancePerTime divide(double divisor) { + return (VoltagePerDistancePerTime) unit().ofBaseUnits(baseUnitMagnitude() / divisor); + } + + @Override + default Velocity per(TimeUnit period) { + return divide(period.of(1)); + } + + + @Override + default Mult> times(Acceleration multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Acceleration divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Angle multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Angle divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(AngularAcceleration multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(AngularAcceleration divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(AngularMomentum multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(AngularMomentum divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(AngularVelocity multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(AngularVelocity divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Current multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Current divisor) { + return (Per) Measure.super.divide(divisor); + } + + @Override + default VoltagePerDistancePerTime divide(Dimensionless divisor) { + return (VoltagePerDistancePerTime) VoltsPerMeterPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + @Override + default VoltagePerDistancePerTime times(Dimensionless multiplier) { + return (VoltagePerDistancePerTime) VoltsPerMeterPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + + @Override + default Mult times(Distance multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Distance divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Energy multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Energy divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Force multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Force divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Frequency multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Frequency divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(LinearAcceleration multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(LinearAcceleration divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(LinearMomentum multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(LinearMomentum divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Voltage times(LinearVelocity multiplier) { + return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(LinearVelocity divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Mass multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Mass divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(MomentOfInertia multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(MomentOfInertia divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Mult multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Mult divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Per multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Per divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Power multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Power divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Temperature multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Temperature divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Time multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Velocity divide(Time divisor) { + return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + + @Override + default Mult times(Torque multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Torque divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Velocity multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Velocity divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Voltage multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Voltage divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Dimensionless divide(VoltagePerDistancePerTime divisor) { + return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + +} diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerDistancePerTimeSquared.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerDistancePerTimeSquared.java new file mode 100644 index 00000000000..c4a1f4f6258 --- /dev/null +++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/VoltagePerDistancePerTimeSquared.java @@ -0,0 +1,378 @@ +// 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 VoltagePerDistancePerTimeSquared extends Measure { + static VoltagePerDistancePerTimeSquared ofRelativeUnits(double magnitude, VoltagePerDistancePerTimeSquaredUnit unit) { + return new ImmutableVoltagePerDistancePerTimeSquared(magnitude, unit.toBaseUnits(magnitude), unit); + } + + static VoltagePerDistancePerTimeSquared ofBaseUnits(double baseUnitMagnitude, VoltagePerDistancePerTimeSquaredUnit unit) { + return new ImmutableVoltagePerDistancePerTimeSquared(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit); + } + + @Override + VoltagePerDistancePerTimeSquared copy(); + + @Override + default MutVoltagePerDistancePerTimeSquared mutableCopy() { + return new MutVoltagePerDistancePerTimeSquared(magnitude(), baseUnitMagnitude(), unit()); + } + + @Override + VoltagePerDistancePerTimeSquaredUnit unit(); + + @Override + default VoltagePerDistancePerTimeSquaredUnit baseUnit() { return (VoltagePerDistancePerTimeSquaredUnit) unit().getBaseUnit(); } + + @Override + default double in(VoltagePerDistancePerTimeSquaredUnit unit) { + return unit.fromBaseUnits(baseUnitMagnitude()); + } + + @Override + default VoltagePerDistancePerTimeSquared unaryMinus() { + return (VoltagePerDistancePerTimeSquared) unit().ofBaseUnits(0 - baseUnitMagnitude()); + } + + @Override + default VoltagePerDistancePerTimeSquared plus(Measure other) { + return (VoltagePerDistancePerTimeSquared) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude()); + } + + @Override + default VoltagePerDistancePerTimeSquared minus(Measure other) { + return (VoltagePerDistancePerTimeSquared) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude()); + } + + @Override + default VoltagePerDistancePerTimeSquared times(double multiplier) { + return (VoltagePerDistancePerTimeSquared) unit().ofBaseUnits(baseUnitMagnitude() * multiplier); + } + + @Override + default VoltagePerDistancePerTimeSquared divide(double divisor) { + return (VoltagePerDistancePerTimeSquared) unit().ofBaseUnits(baseUnitMagnitude() / divisor); + } + + @Override + default Velocity per(TimeUnit period) { + return divide(period.of(1)); + } + + + @Override + default Mult> times(Acceleration multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Acceleration divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Angle multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Angle divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(AngularAcceleration multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(AngularAcceleration divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(AngularMomentum multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(AngularMomentum divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(AngularVelocity multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(AngularVelocity divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Current multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Current divisor) { + return (Per) Measure.super.divide(divisor); + } + + @Override + default VoltagePerDistancePerTimeSquared divide(Dimensionless divisor) { + return (VoltagePerDistancePerTimeSquared) VoltsPerMeterPerSecondSquared.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + @Override + default VoltagePerDistancePerTimeSquared times(Dimensionless multiplier) { + return (VoltagePerDistancePerTimeSquared) VoltsPerMeterPerSecondSquared.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + + @Override + default Mult times(Distance multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Distance divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Energy multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Energy divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Force multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Force divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Frequency multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Frequency divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Voltage times(LinearAcceleration multiplier) { + return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + @Override + default Per divide(LinearAcceleration divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(LinearMomentum multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(LinearMomentum divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(LinearVelocity multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(LinearVelocity divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Mass multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Mass divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(MomentOfInertia multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(MomentOfInertia divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Mult multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Mult divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Per multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Per divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Power multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Power divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Temperature multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Temperature divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Time multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Velocity divide(Time divisor) { + return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + + @Override + default Mult times(Torque multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Torque divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult> times(Velocity multiplier) { + return (Mult>) Measure.super.times(multiplier); + } + + @Override + default Per> divide(Velocity divisor) { + return (Per>) Measure.super.divide(divisor); + } + + + @Override + default Mult times(Voltage multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(Voltage divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerAnglePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerAnglePerTimeSquared divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTime multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Per divide(VoltagePerDistancePerTime divisor) { + return (Per) Measure.super.divide(divisor); + } + + + @Override + default Mult times(VoltagePerDistancePerTimeSquared multiplier) { + return (Mult) Measure.super.times(multiplier); + } + + @Override + default Dimensionless divide(VoltagePerDistancePerTimeSquared divisor) { + return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + +} diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Measure.java b/wpiunits/src/main/java/edu/wpi/first/units/Measure.java index 86c8de9a887..cb4f5ba44f8 100644 --- a/wpiunits/src/main/java/edu/wpi/first/units/Measure.java +++ b/wpiunits/src/main/java/edu/wpi/first/units/Measure.java @@ -30,6 +30,10 @@ import edu.wpi.first.units.measure.Torque; import edu.wpi.first.units.measure.Velocity; import edu.wpi.first.units.measure.Voltage; +import edu.wpi.first.units.measure.VoltagePerAnglePerTime; +import edu.wpi.first.units.measure.VoltagePerAnglePerTimeSquared; +import edu.wpi.first.units.measure.VoltagePerDistancePerTime; +import edu.wpi.first.units.measure.VoltagePerDistancePerTimeSquared; /** * A measure holds the magnitude and unit of some dimension, such as distance, time, or speed. Two @@ -246,6 +250,15 @@ && baseUnit().equals(ratio.denominator().getBaseUnit())) { return times(velocity); } else if (multiplier instanceof Voltage voltage) { return times(voltage); + } else if (multiplier instanceof VoltagePerAnglePerTime voltagePerAnglePerTime) { + return times(voltagePerAnglePerTime); + } else if (multiplier instanceof VoltagePerDistancePerTime voltagePerDistancePerTime) { + return times(voltagePerDistancePerTime); + } else if (multiplier instanceof VoltagePerAnglePerTimeSquared voltagePerAnglePerTimeSquared) { + return times(voltagePerAnglePerTimeSquared); + } else if (multiplier + instanceof VoltagePerDistancePerTimeSquared voltagePerDistancePerTimeSquared) { + return times(voltagePerDistancePerTimeSquared); } else { // Dimensional analysis fallthrough or a generic input measure type // Do a basic unit multiplication @@ -530,6 +543,54 @@ default Measure times(Voltage multiplier) { .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); } + /** + * Multiplies this measure by a voltage per angle per time and returns the resulting measure in + * the most appropriate unit. + * + * @param multiplier the measurement to multiply by. + * @return the multiplication result + */ + default Measure times(VoltagePerAnglePerTime multiplier) { + return MultUnit.combine(unit(), multiplier.unit()) + .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + /** + * Multiplies this measure by a voltage per angle per time squared and returns the resulting + * measure in the most appropriate unit. + * + * @param multiplier the measurement to multiply by. + * @return the multiplication result + */ + default Measure times(VoltagePerAnglePerTimeSquared multiplier) { + return MultUnit.combine(unit(), multiplier.unit()) + .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + /** + * Multiplies this measure by a voltage per distance per time and returns the resulting measure in + * the most appropriate unit. + * + * @param multiplier the measurement to multiply by. + * @return the multiplication result + */ + default Measure times(VoltagePerDistancePerTime multiplier) { + return MultUnit.combine(unit(), multiplier.unit()) + .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + + /** + * Multiplies this measure by a voltage per distance per time squared and returns the resulting + * measure in the most appropriate unit. + * + * @param multiplier the measurement to multiply by. + * @return the multiplication result + */ + default Measure times(VoltagePerDistancePerTimeSquared multiplier) { + return MultUnit.combine(unit(), multiplier.unit()) + .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude()); + } + /** * Multiplies this measure by a conversion factor, returning the converted measurement. Unlike * {@link #times(Per)}, this allows for basic unit cancellation to return measurements of a known @@ -687,6 +748,15 @@ default Measure divide(Measure divisor) { return divide(velocity); } else if (divisor instanceof Voltage voltage) { return divide(voltage); + } else if (divisor instanceof VoltagePerAnglePerTime voltagePerAnglePerTime) { + return divide(voltagePerAnglePerTime); + } else if (divisor instanceof VoltagePerDistancePerTime voltagePerDistancePerTime) { + return divide(voltagePerDistancePerTime); + } else if (divisor instanceof VoltagePerAnglePerTimeSquared voltagePerAnglePerTimeSquared) { + return divide(voltagePerAnglePerTimeSquared); + } else if (divisor + instanceof VoltagePerDistancePerTimeSquared voltagePerDistancePerTimeSquared) { + return divide(voltagePerDistancePerTimeSquared); } else { // Dimensional analysis fallthrough or a generic input measure type // Do a basic unit multiplication @@ -957,6 +1027,54 @@ default Measure divide(Voltage divisor) { .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude()); } + /** + * Divides this measure by a voltage per angle per time and returns the result in the most + * appropriate unit. + * + * @param divisor the measurement to divide by. + * @return the division result + */ + default Measure divide(VoltagePerAnglePerTime divisor) { + return PerUnit.combine(unit(), divisor.unit()) + .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + /** + * Divides this measure by a voltage per angle per time squared and returns the result in the most + * appropriate unit. + * + * @param divisor the measurement to divide by. + * @return the division result + */ + default Measure divide(VoltagePerAnglePerTimeSquared divisor) { + return PerUnit.combine(unit(), divisor.unit()) + .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + /** + * Divides this measure by a voltage per distance per time and returns the result in the most + * appropriate unit. + * + * @param divisor the measurement to divide by. + * @return the division result + */ + default Measure divide(VoltagePerDistancePerTime divisor) { + return PerUnit.combine(unit(), divisor.unit()) + .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + + /** + * Divides this measure by a voltage per distance per time squared and returns the result in the + * most appropriate unit. + * + * @param divisor the measurement to divide by. + * @return the division result + */ + default Measure divide(VoltagePerDistancePerTimeSquared divisor) { + return PerUnit.combine(unit(), divisor.unit()) + .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude()); + } + /** * Divides this measure by a ratio in terms of this measurement's unit to another unit, returning * a measurement in terms of the other unit. diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Units.java b/wpiunits/src/main/java/edu/wpi/first/units/Units.java index cc2042c823e..ba1fcd3d2e7 100644 --- a/wpiunits/src/main/java/edu/wpi/first/units/Units.java +++ b/wpiunits/src/main/java/edu/wpi/first/units/Units.java @@ -499,28 +499,28 @@ private Units() { * A standard unit for measuring linear mechanisms' feedforward voltages based on a model of the * system and a desired commanded linear velocity. */ - public static final PerUnit VoltsPerMeterPerSecond = + public static final VoltagePerDistancePerTimeUnit VoltsPerMeterPerSecond = Volts.per(MetersPerSecond); /** * A standard unit for measuring linear mechanisms' feedforward voltages based on a model of the * system and a desired commanded linear acceleration. */ - public static final PerUnit VoltsPerMeterPerSecondSquared = + public static final VoltagePerDistancePerTimeSquaredUnit VoltsPerMeterPerSecondSquared = Volts.per(MetersPerSecondPerSecond); /** * A standard unit for measuring angular mechanisms' feedforward voltages based on a model of the * system and a desired commanded angular velocity. */ - public static final PerUnit VoltsPerRadianPerSecond = + public static final VoltagePerAnglePerTimeUnit VoltsPerRadianPerSecond = Volts.per(RadiansPerSecond); /** * A standard unit for measuring angular mechanisms' feedforward voltages based on a model of the * system and a desired commanded angular acceleration. */ - public static final PerUnit VoltsPerRadianPerSecondSquared = + public static final VoltagePerAnglePerTimeSquaredUnit VoltsPerRadianPerSecondSquared = Volts.per(RadiansPerSecond.per(Second)); /** diff --git a/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerAnglePerTimeSquaredUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerAnglePerTimeSquaredUnit.java new file mode 100644 index 00000000000..84e335647af --- /dev/null +++ b/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerAnglePerTimeSquaredUnit.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.ImmutableVoltagePerAnglePerTimeSquared; +import edu.wpi.first.units.measure.MutVoltagePerAnglePerTimeSquared; +import edu.wpi.first.units.measure.VoltagePerAnglePerTimeSquared; + +/** + * A unit for measuring angular mechanisms' feedforward voltages based on a model of the system and + * a desired commaned angular acceleration like {@link Units#VoltsPerRadianPerSecondSquared}. + */ +public final class VoltagePerAnglePerTimeSquaredUnit + extends PerUnit { + private static final CombinatoryUnitCache< + VoltageUnit, AngularAccelerationUnit, VoltagePerAnglePerTimeSquaredUnit> + cache = new CombinatoryUnitCache<>(VoltagePerAnglePerTimeSquaredUnit::new); + + VoltagePerAnglePerTimeSquaredUnit(VoltageUnit numerator, AngularAccelerationUnit denominator) { + super( + numerator.isBaseUnit() && denominator.isBaseUnit() + ? null + : combine(numerator.getBaseUnit(), denominator.getBaseUnit()), + numerator, + denominator); + } + + VoltagePerAnglePerTimeSquaredUnit( + VoltagePerAnglePerTimeSquaredUnit baseUnit, + UnaryFunction toBaseConverter, + UnaryFunction fromBaseConverter, + String name, + String symbol) { + super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol); + } + + /** + * Combines a voltage unit and a angular acceleration unit into a unit of voltage per angle per + * time squared. + * + * @param voltage the unit of voltage + * @param angularAcceleration the unit of angular acceleration + * @return the combined voltage per angle per time unit + */ + public static VoltagePerAnglePerTimeSquaredUnit combine( + VoltageUnit voltage, AngularAccelerationUnit angularAcceleration) { + return cache.combine(voltage, angularAcceleration); + } + + @Override + public VoltagePerAnglePerTimeSquaredUnit getBaseUnit() { + return (VoltagePerAnglePerTimeSquaredUnit) super.getBaseUnit(); + } + + @Override + public VoltagePerAnglePerTimeSquared of(double magnitude) { + return new ImmutableVoltagePerAnglePerTimeSquared(magnitude, toBaseUnits(magnitude), this); + } + + @Override + public VoltagePerAnglePerTimeSquared ofBaseUnits(double baseUnitMagnitude) { + return new ImmutableVoltagePerAnglePerTimeSquared( + fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this); + } + + @Override + public VoltagePerAnglePerTimeSquared zero() { + return (VoltagePerAnglePerTimeSquared) super.zero(); + } + + @Override + public VoltagePerAnglePerTimeSquared one() { + return (VoltagePerAnglePerTimeSquared) super.one(); + } + + @Override + public MutVoltagePerAnglePerTimeSquared mutable(double initialMagnitude) { + return new MutVoltagePerAnglePerTimeSquared( + initialMagnitude, toBaseUnits(initialMagnitude), this); + } + + /** + * Creates a ratio unit between this unit and an arbitrary other unit. + * + * @param other the other unit + * @param the type of the other unit + * @return the ratio unit + */ + public PerUnit 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, VoltagePerAnglePerTimeSquaredUnit otherUnit) { + return fromBaseUnits(otherUnit.toBaseUnits(magnitude)); + } +} diff --git a/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerAnglePerTimeUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerAnglePerTimeUnit.java new file mode 100644 index 00000000000..a0bf87e900b --- /dev/null +++ b/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerAnglePerTimeUnit.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.ImmutableVoltagePerAnglePerTime; +import edu.wpi.first.units.measure.MutVoltagePerAnglePerTime; +import edu.wpi.first.units.measure.VoltagePerAnglePerTime; + +/** + * A unit for measuring angular mechanisms' feedforward voltages based on a model of the system and + * a desired commaned angular velocity like {@link Units#VoltsPerRadianPerSecond}. + */ +public final class VoltagePerAnglePerTimeUnit extends PerUnit { + private static final CombinatoryUnitCache< + VoltageUnit, AngularVelocityUnit, VoltagePerAnglePerTimeUnit> + cache = new CombinatoryUnitCache<>(VoltagePerAnglePerTimeUnit::new); + + VoltagePerAnglePerTimeUnit(VoltageUnit numerator, AngularVelocityUnit denominator) { + super( + numerator.isBaseUnit() && denominator.isBaseUnit() + ? null + : combine(numerator.getBaseUnit(), denominator.getBaseUnit()), + numerator, + denominator); + } + + VoltagePerAnglePerTimeUnit( + VoltagePerAnglePerTimeUnit baseUnit, + UnaryFunction toBaseConverter, + UnaryFunction fromBaseConverter, + String name, + String symbol) { + super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol); + } + + /** + * Combines a voltage unit and a angular velocity unit into a unit of voltage per angle per time. + * + * @param voltage the unit of voltage + * @param angularVelocity the unit of angular velocity + * @return the combined voltage per angle per time unit + */ + public static VoltagePerAnglePerTimeUnit combine( + VoltageUnit voltage, AngularVelocityUnit angularVelocity) { + return cache.combine(voltage, angularVelocity); + } + + @Override + public VoltagePerAnglePerTimeUnit getBaseUnit() { + return (VoltagePerAnglePerTimeUnit) super.getBaseUnit(); + } + + @Override + public VoltagePerAnglePerTime of(double magnitude) { + return new ImmutableVoltagePerAnglePerTime(magnitude, toBaseUnits(magnitude), this); + } + + @Override + public VoltagePerAnglePerTime ofBaseUnits(double baseUnitMagnitude) { + return new ImmutableVoltagePerAnglePerTime( + fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this); + } + + @Override + public VoltagePerAnglePerTime zero() { + return (VoltagePerAnglePerTime) super.zero(); + } + + @Override + public VoltagePerAnglePerTime one() { + return (VoltagePerAnglePerTime) super.one(); + } + + @Override + public MutVoltagePerAnglePerTime mutable(double initialMagnitude) { + return new MutVoltagePerAnglePerTime(initialMagnitude, toBaseUnits(initialMagnitude), this); + } + + /** + * Creates a ratio unit between this unit and an arbitrary other unit. + * + * @param other the other unit + * @param the type of the other unit + * @return the ratio unit + */ + public PerUnit 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, VoltagePerAnglePerTimeUnit otherUnit) { + return fromBaseUnits(otherUnit.toBaseUnits(magnitude)); + } +} diff --git a/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerDistancePerTimeSquaredUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerDistancePerTimeSquaredUnit.java new file mode 100644 index 00000000000..119d73001a8 --- /dev/null +++ b/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerDistancePerTimeSquaredUnit.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.ImmutableVoltagePerDistancePerTimeSquared; +import edu.wpi.first.units.measure.MutVoltagePerDistancePerTimeSquared; +import edu.wpi.first.units.measure.VoltagePerDistancePerTimeSquared; + +/** + * A unit for measuring linear mechanisms' feedforward voltages based on a model of the system and a + * desired commaned linear acceleration like {@link Units#VoltsPerMeterPerSecondSquared}. + */ +public final class VoltagePerDistancePerTimeSquaredUnit + extends PerUnit { + private static final CombinatoryUnitCache< + VoltageUnit, LinearAccelerationUnit, VoltagePerDistancePerTimeSquaredUnit> + cache = new CombinatoryUnitCache<>(VoltagePerDistancePerTimeSquaredUnit::new); + + VoltagePerDistancePerTimeSquaredUnit(VoltageUnit numerator, LinearAccelerationUnit denominator) { + super( + numerator.isBaseUnit() && denominator.isBaseUnit() + ? null + : combine(numerator.getBaseUnit(), denominator.getBaseUnit()), + numerator, + denominator); + } + + VoltagePerDistancePerTimeSquaredUnit( + VoltagePerDistancePerTimeSquaredUnit baseUnit, + UnaryFunction toBaseConverter, + UnaryFunction fromBaseConverter, + String name, + String symbol) { + super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol); + } + + /** + * Combines a voltage unit and a linear acceleration unit into a unit of voltage per distance per + * time squared. + * + * @param voltage the unit of voltage + * @param linearAcceleration the unit of linear acceleration + * @return the combined voltage per distance per time unit + */ + public static VoltagePerDistancePerTimeSquaredUnit combine( + VoltageUnit voltage, LinearAccelerationUnit linearAcceleration) { + return cache.combine(voltage, linearAcceleration); + } + + @Override + public VoltagePerDistancePerTimeSquaredUnit getBaseUnit() { + return (VoltagePerDistancePerTimeSquaredUnit) super.getBaseUnit(); + } + + @Override + public VoltagePerDistancePerTimeSquared of(double magnitude) { + return new ImmutableVoltagePerDistancePerTimeSquared(magnitude, toBaseUnits(magnitude), this); + } + + @Override + public VoltagePerDistancePerTimeSquared ofBaseUnits(double baseUnitMagnitude) { + return new ImmutableVoltagePerDistancePerTimeSquared( + fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this); + } + + @Override + public VoltagePerDistancePerTimeSquared zero() { + return (VoltagePerDistancePerTimeSquared) super.zero(); + } + + @Override + public VoltagePerDistancePerTimeSquared one() { + return (VoltagePerDistancePerTimeSquared) super.one(); + } + + @Override + public MutVoltagePerDistancePerTimeSquared mutable(double initialMagnitude) { + return new MutVoltagePerDistancePerTimeSquared( + initialMagnitude, toBaseUnits(initialMagnitude), this); + } + + /** + * Creates a ratio unit between this unit and an arbitrary other unit. + * + * @param other the other unit + * @param the type of the other unit + * @return the ratio unit + */ + public PerUnit 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, VoltagePerDistancePerTimeSquaredUnit otherUnit) { + return fromBaseUnits(otherUnit.toBaseUnits(magnitude)); + } +} diff --git a/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerDistancePerTimeUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerDistancePerTimeUnit.java new file mode 100644 index 00000000000..97a17099f0b --- /dev/null +++ b/wpiunits/src/main/java/edu/wpi/first/units/VoltagePerDistancePerTimeUnit.java @@ -0,0 +1,103 @@ +// 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.ImmutableVoltagePerDistancePerTime; +import edu.wpi.first.units.measure.MutVoltagePerDistancePerTime; +import edu.wpi.first.units.measure.VoltagePerDistancePerTime; + +/** + * A unit for measuring linear mechanisms' feedforward voltages based on a model of the system and a + * desired commaned linear velocity like {@link Units#VoltsPerMeterPerSecond}. + */ +public final class VoltagePerDistancePerTimeUnit extends PerUnit { + private static final CombinatoryUnitCache< + VoltageUnit, LinearVelocityUnit, VoltagePerDistancePerTimeUnit> + cache = new CombinatoryUnitCache<>(VoltagePerDistancePerTimeUnit::new); + + VoltagePerDistancePerTimeUnit(VoltageUnit numerator, LinearVelocityUnit denominator) { + super( + numerator.isBaseUnit() && denominator.isBaseUnit() + ? null + : combine(numerator.getBaseUnit(), denominator.getBaseUnit()), + numerator, + denominator); + } + + VoltagePerDistancePerTimeUnit( + VoltagePerDistancePerTimeUnit baseUnit, + UnaryFunction toBaseConverter, + UnaryFunction fromBaseConverter, + String name, + String symbol) { + super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol); + } + + /** + * Combines a voltage unit and a linear velocity unit into a unit of voltage per distance per + * time. + * + * @param voltage the unit of voltage + * @param linearVelocity the unit of linear velocity + * @return the combined voltage per distance per time unit + */ + public static VoltagePerDistancePerTimeUnit combine( + VoltageUnit voltage, LinearVelocityUnit linearVelocity) { + return cache.combine(voltage, linearVelocity); + } + + @Override + public VoltagePerDistancePerTimeUnit getBaseUnit() { + return (VoltagePerDistancePerTimeUnit) super.getBaseUnit(); + } + + @Override + public VoltagePerDistancePerTime of(double magnitude) { + return new ImmutableVoltagePerDistancePerTime(magnitude, toBaseUnits(magnitude), this); + } + + @Override + public VoltagePerDistancePerTime ofBaseUnits(double baseUnitMagnitude) { + return new ImmutableVoltagePerDistancePerTime( + fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this); + } + + @Override + public VoltagePerDistancePerTime zero() { + return (VoltagePerDistancePerTime) super.zero(); + } + + @Override + public VoltagePerDistancePerTime one() { + return (VoltagePerDistancePerTime) super.one(); + } + + @Override + public MutVoltagePerDistancePerTime mutable(double initialMagnitude) { + return new MutVoltagePerDistancePerTime(initialMagnitude, toBaseUnits(initialMagnitude), this); + } + + /** + * Creates a ratio unit between this unit and an arbitrary other unit. + * + * @param other the other unit + * @param the type of the other unit + * @return the ratio unit + */ + public PerUnit 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, VoltagePerDistancePerTimeUnit otherUnit) { + return fromBaseUnits(otherUnit.toBaseUnits(magnitude)); + } +} diff --git a/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java index 07774031b0c..90d3fbbf2bc 100644 --- a/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java +++ b/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java @@ -81,6 +81,50 @@ public VelocityUnit per(TimeUnit period) { return VelocityUnit.combine(this, period); } + /** + * Combines this voltage with an angular velocity unit to form a unit of voltage per angle per + * time. + * + * @param angularVelocityUnit the angular velocity unit + * @return the voltage per angle per time unit + */ + public VoltagePerAnglePerTimeUnit per(AngularVelocityUnit angularVelocityUnit) { + return VoltagePerAnglePerTimeUnit.combine(this, angularVelocityUnit); + } + + /** + * Combines this voltage with an angular acceleration unit to form a unit of voltage per angle per + * time squared. + * + * @param angularAccelerationUnit the angular acceleration unit + * @return the voltage per angle per time squared unit + */ + public VoltagePerAnglePerTimeSquaredUnit per(AngularAccelerationUnit angularAccelerationUnit) { + return VoltagePerAnglePerTimeSquaredUnit.combine(this, angularAccelerationUnit); + } + + /** + * Combines this voltage with a linear velocity unit to form a unit of voltage per distance per + * time. + * + * @param linearVelocityUnit the linear velocity unit + * @return the voltage per distance per time unit + */ + public VoltagePerDistancePerTimeUnit per(LinearVelocityUnit linearVelocityUnit) { + return VoltagePerDistancePerTimeUnit.combine(this, linearVelocityUnit); + } + + /** + * Combines this voltage with an linear acceleration unit to form a unit of voltage per distance + * per time squared. + * + * @param linearAccelerationUnit the linear acceleration unit + * @return the voltage per distance per time squared unit + */ + public VoltagePerDistancePerTimeSquaredUnit per(LinearAccelerationUnit linearAccelerationUnit) { + return VoltagePerDistancePerTimeSquaredUnit.combine(this, linearAccelerationUnit); + } + /** * Creates a generic ratio unit of this voltage to a different unit type. *