wip: Add angular acceleration generator

README.md

@@ -123,7 +123,7 @@ a module.
 ## Supported quantities
 - [x] acceleration
 - [x] angle
-- [ ] angular acceleration
+- [x] angular acceleration
 - [x] angular speed (spin)
 - [ ] angular momentum
 - [x] area

example-configs/balls2d.gddl

@@ -30,6 +30,12 @@
 		allowComparisons = false,
 		spin = "Spin"
 	}],
+	angularAccelerations = [{
+		className = "AngularAcceleration",
+		floatType = "Double",
+		spin = "Spin",
+		createNumberExtensions = true
+	}],
 	densities = [{
 		className = "Density",
 		number = "FixDensity",
@@ -113,6 +119,7 @@
 		oneUnit = "Degrees per second",
 		displayUnit = "Degrees per second",
 		angle = "Angle",
+		acceleration = "AngularAcceleration",
 		createNumberExtensions = true
 	}]
 }

src/main/kotlin/fixie/generator/acceleration/AngularAccelerationClass.kt

@@ -0,0 +1,22 @@
+package fixie.generator.acceleration
+
+import fixie.generator.number.FloatType
+import fixie.generator.quantity.FloatQuantityClass
+import fixie.generator.quantity.QuantityUnit
+import fixie.generator.spin.SpinClass
+
+class AngularAccelerationClass(
+	className: String,
+	floatType: FloatType,
+	val spinClassName: String?,
+	createNumberExtensions: Boolean
+) : FloatQuantityClass(className, floatType, createNumberExtensions) {
+
+	var spin: SpinClass? = null
+
+	override fun getSupportedUnits() = listOf(
+		QuantityUnit(
+			"RADPS2", "", "rad/s^2", "radps2", 0.0001, 1e6, 1.0
+		)
+	)
+}

src/main/kotlin/fixie/generator/acceleration/AngularAccelerationClassGenerator.kt

@@ -0,0 +1,40 @@
+package fixie.generator.acceleration
+
+import fixie.generator.quantity.FloatQuantityClassGenerator
+import java.io.PrintWriter
+
+class AngularAccelerationClassGenerator(
+	writer: PrintWriter,
+	quantity: AngularAccelerationClass,
+	packageName: String
+) : FloatQuantityClassGenerator<AngularAccelerationClass>(writer, quantity, packageName) {
+
+	override fun getImports() = super.getImports() + arrayOf("kotlin.time.Duration", "kotlin.time.DurationUnit")
+
+	override fun generateToDoubleComment() {
+		writer.println("\t/** Gets the angular acceleration value, in rad/s^2 */")
+	}
+
+	override fun generateToString() {
+		writer.println()
+		writer.println("\toverride fun toString() = String.format(\"%.2f%s\", value, \"rad/s^2\")")
+	}
+
+	override fun generateArithmetic() {
+		super.generateArithmetic()
+
+		if (quantity.spin != null) {
+			writer.println()
+			writer.println("\toperator fun times(right: Duration) = value * ${quantity.spinClassName}.RADIANS_PER_SECOND * right.toDouble(DurationUnit.SECONDS)")
+		}
+	}
+
+	override fun generateExtensionFunctions() {
+		super.generateExtensionFunctions()
+
+		if (quantity.spin != null) {
+			writer.println()
+			writer.println("operator fun Duration.times(right: ${quantity.className}) = right * this")
+		}
+	}
+}

src/main/kotlin/fixie/generator/acceleration/AngularAccelerationTestsGenerator.kt

@@ -0,0 +1,33 @@
+package fixie.generator.acceleration
+
+import fixie.generator.quantity.FloatQuantityTestsGenerator
+import java.io.PrintWriter
+
+class AngularAccelerationTestsGenerator(
+	writer: PrintWriter,
+	quantity: AngularAccelerationClass,
+	packageName: String
+) : FloatQuantityTestsGenerator<AngularAccelerationClass>(writer, quantity, packageName) {
+
+	override fun getImports() = super.getImports() + arrayOf("kotlin.time.Duration.Companion.seconds")
+
+	override fun generateToStringBody() {
+		writer.println("\t\tassertEquals(\"2.34rad/s^2\", (${quantity.className}.RADPS2 * 2.34).toString())")
+	}
+
+	override fun generateArithmeticBody() {
+		super.generateArithmeticBody()
+
+		if (quantity.spin != null) {
+			writer.println("\t\tassertEquals(0.8, ((${quantity.className}.RADPS2 * 0.2) * 4.seconds).toDouble(SpinUnit.RADIANS_PER_SECOND), 0.01)")
+		}
+	}
+
+	override fun generateExtensionFunctionsBody() {
+		super.generateExtensionFunctionsBody()
+
+		if (quantity.spin != null) {
+			writer.println("\t\tassertEquals(0.8, (4.seconds * (${quantity.className}.RADPS2 * 0.2)).toDouble(SpinUnit.RADIANS_PER_SECOND), 0.01)")
+		}
+	}
+}

src/main/kotlin/fixie/generator/module/FixieModule.kt

@@ -1,6 +1,7 @@
 package fixie.generator.module
 
 import fixie.generator.acceleration.AccelerationClass
+import fixie.generator.acceleration.AngularAccelerationClass
 import fixie.generator.angle.AngleClass
 import fixie.generator.area.AreaClass
 import fixie.generator.density.DensityClass
@@ -22,6 +23,7 @@ class FixieModule(
 	val numbers: List<NumberClass>,
 	val accelerations: List<AccelerationClass> = emptyList(),
 	val angles: List<AngleClass> = emptyList(),
+	val angularAccelerations: List<AngularAccelerationClass> = emptyList(),
 	val areas: List<AreaClass> = emptyList(),
 	val volumes: List<VolumeClass> = emptyList(),
 	val masses: List<MassClass> = emptyList(),
@@ -112,13 +114,16 @@ class FixieModule(
 			speed.acceleration = acceleration
 		}
 		resolve(speed, squareSpeed, { it.squareClassName }) { speed, square -> speed.square = square }
+		resolve(spins, angularAccelerations, { it.accelerationClassName }) { spin, acceleration -> spin.acceleration = acceleration }
 		resolve(spins, angles, { it.angleClassName }) { spin, angle -> spin.angle = angle }
+		resolve(angularAccelerations, spins, { it.spinClassName }) { acceleration, spin -> acceleration.spin = spin }
 
 		val allClassNames = numbers.map { it.className } +
 				displacements.map { it.className } + areas.map { it.className } + volumes.map { it.className } +
 				speed.map { it.className } + squareSpeed.map { it.className } + accelerations.map { it.className } +
 				masses.map { it.className } + momenta.map { it.className } + squareMomenta.map { it.className } +
-				angles.map { it.className } + spins.map { it.className } + densities.map { it.className }
+				angles.map { it.className } + spins.map { it.className } + angularAccelerations.map { it.className } +
+				densities.map { it.className }
 
 		for (className in allClassNames) {
 			if (allClassNames.count { it == className } > 1) {

src/main/kotlin/fixie/generator/module/ModuleGenerator.kt

@@ -2,6 +2,8 @@ package fixie.generator.module
 
 import fixie.generator.acceleration.AccelerationClassGenerator
 import fixie.generator.acceleration.AccelerationTestsGenerator
+import fixie.generator.acceleration.AngularAccelerationClassGenerator
+import fixie.generator.acceleration.AngularAccelerationTestsGenerator
 import fixie.generator.angle.AngleClassGenerator
 import fixie.generator.angle.AngleTestsGenerator
 import fixie.generator.angle.AngleUnit
@@ -108,6 +110,7 @@ fun generateModule(module: FixieModule, directory: File, clearExistingFiles: Boo
 	generateQuantityFiles(module.squareSpeed, ::SquareSpeedClassGenerator, ::SquareSpeedTestsGenerator)
 	generateQuantityFiles(module.accelerations, ::AccelerationClassGenerator, ::AccelerationTestsGenerator)
 	generateQuantityFiles(module.angles, ::AngleClassGenerator, ::AngleTestsGenerator)
+	generateQuantityFiles(module.angularAccelerations, ::AngularAccelerationClassGenerator, ::AngularAccelerationTestsGenerator)
 	generateQuantityFiles(module.spins, ::SpinClassGenerator, ::SpinTestsGenerator)
 	generateQuantityFiles(module.densities, ::DensityClassGenerator, ::DensityTestsGenerator)
 	generateQuantityFiles(module.momenta, ::MomentumClassGenerator, ::MomentumTestsGenerator)

src/main/kotlin/fixie/generator/parser/ModuleParser.kt

@@ -6,6 +6,7 @@ import dev.gigaherz.util.gddl2.structure.GddlDocument
 import dev.gigaherz.util.gddl2.structure.GddlMap
 import dev.gigaherz.util.gddl2.structure.GddlValue
 import fixie.generator.acceleration.AccelerationClass
+import fixie.generator.acceleration.AngularAccelerationClass
 import fixie.generator.angle.AngleClass
 import fixie.generator.angle.AngleUnit
 import fixie.generator.area.AreaClass
@@ -232,6 +233,13 @@ private class ModuleParser(
 		spinClassName = optionalString(properties, "spin", path)
 	)
 
+	private fun loadAngularAcceleration(properties: GddlMap, path: String) = AngularAccelerationClass(
+		className = requiredString(properties, "className", path),
+		floatType = requiredFloatType(properties, "floatType", path),
+		spinClassName = optionalString(properties, "spin", path),
+		createNumberExtensions = requiredBoolean(properties, "createNumberExtensions", path)
+	)
+
 	private fun loadVolume(properties: GddlMap, path: String) = VolumeClass(
 		className = requiredString(properties, "className", path),
 		floatType = requiredFloatType(properties, "floatType", path),
@@ -290,6 +298,7 @@ private class ModuleParser(
 		oneUnit = requiredUnit(properties, "oneUnit", path, SpinUnit.entries),
 		displayUnit = requiredUnit(properties, "displayUnit", path, SpinUnit.entries),
 		angleClassName = optionalString(properties, "angle", path),
+		accelerationClassName = optionalString(properties, "acceleration", path),
 		createNumberExtensions = requiredBoolean(properties, "createNumberExtensions", path)
 	)
 
@@ -362,6 +371,7 @@ private class ModuleParser(
 
 		val accelerations = mapList(root, "accelerations", "(root)", ::loadAcceleration)
 		val angles = mapList(root, "angles", "(root)", ::loadAngle)
+		val angularAccelerations = mapList(root, "angularAccelerations", "(root)", ::loadAngularAcceleration)
 		val volumes = mapList(root, "volumes", "(root)", ::loadVolume)
 		val areas = mapList(root, "areas", "(root)", ::loadArea)
 		val displacements = mapList(root, "displacements", "(root)", ::loadDisplacement)
@@ -380,6 +390,7 @@ private class ModuleParser(
 				numbers = numbers,
 				accelerations = accelerations,
 				angles = angles,
+				angularAccelerations = angularAccelerations,
 				volumes = volumes,
 				areas = areas,
 				displacements = displacements,

src/main/kotlin/fixie/generator/spin/SpinClass.kt

@@ -1,5 +1,6 @@
 package fixie.generator.spin
 
+import fixie.generator.acceleration.AngularAccelerationClass
 import fixie.generator.angle.AngleClass
 import fixie.generator.number.FloatType
 import fixie.generator.quantity.FloatQuantityClass
@@ -11,10 +12,12 @@ class SpinClass(
 	val oneUnit: SpinUnit,
 	val displayUnit: SpinUnit,
 	val angleClassName: String?,
+	val accelerationClassName: String?,
 	createNumberExtensions: Boolean
 ) : FloatQuantityClass(className, floatType, createNumberExtensions) {
 
 	var angle: AngleClass? = null
+	var acceleration: AngularAccelerationClass? = null
 
 	override fun getSupportedUnits() = SpinUnit.entries.map {
 		QuantityUnit(

src/main/kotlin/fixie/generator/spin/SpinClassGenerator.kt

@@ -1,6 +1,5 @@
 package fixie.generator.spin
 
-import fixie.generator.number.FloatType
 import fixie.generator.quantity.FloatQuantityClassGenerator
 import java.io.PrintWriter
 
@@ -10,7 +9,7 @@ class SpinClassGenerator(
 	packageName: String
 ) : FloatQuantityClassGenerator<SpinClass>(writer, spin, packageName) {
 
-	override fun getImports() = super.getImports() + if (quantity.angleClassName != null) {
+	override fun getImports() = super.getImports() + if (quantity.angle != null || quantity.acceleration != null) {
 		arrayOf("kotlin.time.Duration", "kotlin.time.DurationUnit")
 	} else emptyArray()
 
@@ -33,11 +32,11 @@ class SpinClassGenerator(
 			writer.println("\toperator fun times(right: Duration) = ${quantity.angleClassName}.$functionName(value * right.toDouble(DurationUnit.SECONDS))")
 		}
 
-		// TODO Angular acceleration?
-//        if (speed.acceleration != null) {
-//            writer.println()
-//            writer.println("\toperator fun div(right: Duration) = toDouble(SpeedUnit.METERS_PER_SECOND) * ${speed.acceleration.className}.MPS2 / right.toDouble(DurationUnit.SECONDS)")
-//        }
+        if (quantity.acceleration != null) {
+            writer.println()
+            writer.println("\toperator fun div(right: Duration) = toDouble(SpinUnit.RADIANS_PER_SECOND) * " +
+					"${quantity.accelerationClassName}.RADPS2 / right.toDouble(DurationUnit.SECONDS)")
+        }
 	}
 
 	override fun generateExtensionFunctions() {

src/main/kotlin/fixie/generator/spin/SpinTestsGenerator.kt

@@ -12,9 +12,9 @@ class SpinTestsGenerator(
 	private val dps = "${quantity.className}.DEGREES_PER_SECOND"
 	private val rps = "${quantity.className}.RADIANS_PER_SECOND"
 
-	override fun getImports() = super.getImports() + arrayOf("kotlin.math.PI") + if (quantity.angleClassName != null) {
-		arrayOf("kotlin.time.Duration.Companion.seconds")
-	} else emptyArray()
+	override fun getImports() = super.getImports() + arrayOf("kotlin.math.PI") + if (
+		quantity.angle != null || quantity.acceleration != null
+		) { arrayOf("kotlin.time.Duration.Companion.seconds") } else emptyArray()
 
 	override fun generateToDoubleBody() {
 		super.generateToDoubleBody()
@@ -59,6 +59,9 @@ class SpinTestsGenerator(
 			val margin = if (angle.internalType.numBytes == 1) 5.0 else 0.5
 			writer.println("\t\tassertEquals(150.0, (3.seconds * (50 * $dps)).toDouble(AngleUnit.DEGREES), $margin)")
 		}
+		if (quantity.acceleration != null) {
+			writer.println("\t\tassertEquals(2.5, ((15 * $rps) / 6.seconds).toDouble(), 0.001)")
+		}
 	}
 
 	override fun generateMathFunctionsBody() {