Add conversion to units relating to rotational dynamics units and add…

… unit tests

shared/src/main/scala/squants/mass/Mass.scala

@@ -39,6 +39,12 @@ final class Mass private (val value: Double, val unit: MassUnit)
   def /(that: AreaDensity): Area = SquareMeters(toKilograms / that.toKilogramsPerSquareMeter)
   def /(that: Area): AreaDensity = KilogramsPerSquareMeter(toKilograms / that.toSquareMeters)
 
+  /**
+    * @param radius length to center of rotation
+    * @return moment of inertia of a point mass with given mass and radius
+    */
+  def onRadius(radius: Length): MomentOfInertia = KilogramsMetersSquared(toKilograms * radius.squared.toSquareMeters)
+
   def toMicrograms = to(Micrograms)
   def toMilligrams = to(Milligrams)
   def toGrams = to(Grams)

shared/src/main/scala/squants/mass/MomentOfIntertia.scala

@@ -2,7 +2,7 @@ package squants.mass
 
 import squants.motion.{AngularAcceleration, NewtonMeters, Torque}
 import squants.space.{Feet, Meters}
-import squants.{Dimension, PrimaryUnit, SiBaseUnit, StrictlyPositiveQuantity, UnitConverter, UnitOfMeasure}
+import squants.{AbstractQuantityNumeric, Dimension, Length, PrimaryUnit, SiBaseUnit, StrictlyPositiveQuantity, UnitConverter, UnitOfMeasure}
 
 /**
   *
@@ -20,10 +20,19 @@ final class MomentOfInertia private (val value: Double, val unit: MomentOfInerti
   def toPoundsSquareFeet = to(PoundsSquareFeet)
 
   def *(angularAcceleration: AngularAcceleration): Torque = {
-    val kilogramsMetersSquared = toKilogramsMetersSquared
     val radiansPerSecondSquared = angularAcceleration.toRadiansPerSecondSquared
 
-    NewtonMeters(kilogramsMetersSquared * radiansPerSecondSquared)
+    NewtonMeters(toKilogramsMetersSquared * radiansPerSecondSquared)
+  }
+
+  /**
+    * For a point mass with the given MomentOfInertia rotating with a center of
+    * rotation at the given radius, return the mass of the point mass
+    * @param radius distance to axis of rotation
+    * @return mass of point mass with given radius and MomentOfInertia
+    */
+  def atCenter(radius: Length): Mass = {
+    Kilograms(toKilogramsMetersSquared / radius.squared.toSquareMeters)
   }
 }
 
@@ -49,4 +58,16 @@ object KilogramsMetersSquared extends MomentOfInertiaUnit with PrimaryUnit with
 object PoundsSquareFeet extends MomentOfInertiaUnit {
   val symbol = Pounds.symbol + "‧" + Feet.symbol + "²"
   val conversionFactor = Pounds.conversionFactor * math.pow(Feet.conversionFactor, 2D)
+}
+
+object MomentOfInertiaConversions {
+  lazy val kilogramMetersSquared = KilogramsMetersSquared(1)
+  lazy val poundSquareFeet = PoundsSquareFeet(1)
+
+  implicit class MomentOfInertiaConversions[A](val n: A) extends AnyVal {
+    def kilogramMetersSquared(implicit num: Numeric[A]) = KilogramsMetersSquared(n)
+    def poundSquareFeet(implicit num: Numeric[A]) = PoundsSquareFeet(n)
+  }
+
+  implicit object MomentOfInertiaNumeric extends AbstractQuantityNumeric[MomentOfInertia](MomentOfInertia.primaryUnit)
 }

shared/src/main/scala/squants/motion/AngularAcceleration.scala

@@ -3,7 +3,7 @@ package squants.motion
 import squants.mass.MomentOfInertia
 import squants.space._
 import squants.time.{Seconds, Time, TimeDerivative}
-import squants.{Dimension, Length, PrimaryUnit, Quantity, SiUnit, UnitConverter, UnitOfMeasure}
+import squants.{AbstractQuantityNumeric, Dimension, Length, PrimaryUnit, Quantity, SiUnit, UnitConverter, UnitOfMeasure}
 
 /**
   *
@@ -18,10 +18,20 @@ final class AngularAcceleration private (val value: Double, val unit: AngularAcc
   def dimension = AngularAcceleration
 
   def toRadiansPerSecondSquared = to(RadiansPerSecondSquared)
+  def toDegreesPerSecondSquared = to(DegreesPerSecondSquared)
+  def toGradsPerSecondSquared = to(GradsPerSecondSquared)
+  def toTurnsPerSecondSquared = to(TurnsPerSecondSquared)
+  def toArcminutesPerSecondSquared = to(ArcminutesPerSecondSquared)
+  def toArcsecondsPerSecondSquared = to(ArcsecondsPerSecondSquared)
+
+  /**
+    * linear acceleration of an object rotating with this angular acceleration
+    * and the given radius from the center of rotation
+    * @param radius the distance from the center of rotation
+    * @return linear acceleration with given angular acceleration and radius
+    */
+  def onRadius(radius: Length): Acceleration = toRadiansPerSecondSquared * radius / Seconds(1).squared
 
-  def onRadius(that: Length): Acceleration = {
-    toRadiansPerSecondSquared * that / Seconds(1).squared
-  }
 
   def *(that: MomentOfInertia): Torque = {
     NewtonMeters(toRadiansPerSecondSquared * that.toKilogramsMetersSquared)
@@ -32,7 +42,6 @@ final class AngularAcceleration private (val value: Double, val unit: AngularAcc
   override protected[squants] def time: Time = Seconds(1)
 }
 
-
 object AngularAcceleration extends Dimension[AngularAcceleration] {
   private[motion] def apply[A](n: A, unit: AngularAccelerationUnit)(implicit num: Numeric[A]) = new AngularAcceleration(num.toDouble(n), unit)
   def apply = parse _
@@ -42,7 +51,7 @@ object AngularAcceleration extends Dimension[AngularAcceleration] {
   def units = Set(
     RadiansPerSecondSquared,
     DegreesPerSecondSquared,
-    GradiansPerSecondSquared,
+    GradsPerSecondSquared,
     TurnsPerSecondSquared,
     ArcminutesPerSecondSquared,
     ArcsecondsPerSecondSquared)
@@ -58,15 +67,15 @@ trait AngularAccelerationUnit extends UnitOfMeasure[AngularAcceleration] with
 }
 
 object RadiansPerSecondSquared extends AngularAccelerationUnit with PrimaryUnit with SiUnit{
-  override val symbol: String = "rad/s²"
+  val symbol = Radians.symbol + "/s²"
 }
 
 object DegreesPerSecondSquared extends AngularAccelerationUnit {
-  val symbol = "°/s²"
+  val symbol = Degrees.symbol + "/s²"
   val conversionFactor = Degrees.conversionFactor
 }
 
-object GradiansPerSecondSquared extends AngularAccelerationUnit {
+object GradsPerSecondSquared extends AngularAccelerationUnit {
   val symbol = Gradians.symbol + "/s²"
   val conversionFactor = Gradians.conversionFactor
 }
@@ -84,4 +93,20 @@ object ArcminutesPerSecondSquared extends AngularAccelerationUnit {
 object ArcsecondsPerSecondSquared extends AngularAccelerationUnit{
   val symbol = Arcseconds.symbol + "/s²"
   val conversionFactor = Arcseconds.conversionFactor
+}
+
+object AngularAccelerationConversions {
+  lazy val radianPerSecondSquared = RadiansPerSecondSquared(1)
+  lazy val degreePerSecondSquared = DegreesPerSecondSquared(1)
+  lazy val gradPerSecondSquared = GradsPerSecondSquared(1)
+  lazy val turnPerSecondSquared = TurnsPerSecondSquared(1)
+
+  implicit class AngularAccelerationConversions[A](val n: A) extends AnyVal {
+    def radiansPerSecondSquared(implicit num: Numeric[A]) = RadiansPerSecondSquared(n)
+    def degreesPerSecondSquared(implicit num: Numeric[A]) = DegreesPerSecondSquared(n)
+    def gradsPerSecondSquared(implicit num: Numeric[A]) = GradsPerSecondSquared(n)
+    def turnsPerSecondSquared(implicit num: Numeric[A]) = TurnsPerSecondSquared(n)
+  }
+
+  implicit object AngularAccelerationNumeric extends AbstractQuantityNumeric[AngularAcceleration](AngularAcceleration.primaryUnit)
 }

shared/src/main/scala/squants/motion/AngularVelocity.scala

@@ -28,9 +28,13 @@ final class AngularVelocity private (val value: Double, val unit: AngularVelocit
   def toGradsPerSecond = to(GradsPerSecond)
   def toTurnsPerSecond = to(TurnsPerSecond)
 
-  def onRadius(that: Length): Velocity = {
-    toRadiansPerSecond * that / Seconds(1)
-  }
+  /**
+    * linear velocity of an object rotating with this angular velocity
+    * and the given radius from the center of rotation
+    * @param radius the distance from the center of rotation
+    * @return linear velocity with given angular velocity and radius
+    */
+  def onRadius(radius: Length): Velocity = toRadiansPerSecond * radius / Seconds(1)
 
   protected[squants] def timeIntegrated: Angle = Radians(toRadiansPerSecond)
 

shared/src/main/scala/squants/motion/Torque.scala

@@ -1,8 +1,8 @@
 package squants.motion
 
-import squants.mass.{MomentOfInertia, Pounds}
+import squants.mass.{Kilograms, MomentOfInertia, Pounds}
 import squants.space.{Feet, Meters}
-import squants.{Dimension, Energy, PrimaryUnit, Quantity, SiBaseUnit, UnitConverter, UnitOfMeasure}
+import squants.{AbstractQuantityNumeric, Dimension, Energy, PrimaryUnit, Quantity, SiBaseUnit, UnitConverter, UnitOfMeasure}
 
 /**
   *
@@ -17,6 +17,7 @@ final class Torque private (val value: Double, val unit: TorqueUnit)
   def dimension = Torque
 
   def toNewtonMeters = to(NewtonMeters)
+  def toPoundFeet = to(PoundFeet)
 
   def / (that: MomentOfInertia): AngularAcceleration = {
     RadiansPerSecondSquared(toNewtonMeters / that.toKilogramsMetersSquared)
@@ -26,7 +27,7 @@ final class Torque private (val value: Double, val unit: TorqueUnit)
 object Torque extends Dimension[Torque] {
   private[motion] def apply[A](n: A, unit: TorqueUnit)(implicit num: Numeric[A]) = new Torque(num.toDouble(n), unit)
   def apply = parse _
-  def name = "MomentOfInertia"
+  def name = "Torque"
   def primaryUnit = NewtonMeters
   def siUnit = NewtonMeters
   def units = Set(NewtonMeters, PoundFeet)
@@ -44,5 +45,17 @@ object NewtonMeters extends TorqueUnit with PrimaryUnit with  SiBaseUnit {
 
 object PoundFeet extends TorqueUnit {
   val symbol = Pounds.symbol + "‧" + Feet.symbol
-  val conversionFactor = Pounds.conversionFactor * Feet.conversionFactor
+  val conversionFactor = PoundForce.conversionFactor * Feet.conversionFactor
+}
+
+object TorqueConversions {
+  lazy val newtonMeters = NewtonMeters(1)
+  lazy val poundFeet = PoundFeet(1)
+
+  implicit class TorqueConversions[A](val n: A) extends AnyVal {
+    def newtonMeters(implicit num: Numeric[A]) = NewtonMeters(n)
+    def poundFeet(implicit num: Numeric[A]) = PoundFeet(n)
+  }
+
+  implicit object TorqueNumeric extends AbstractQuantityNumeric[Torque](Torque.primaryUnit)
 }

shared/src/main/scala/squants/space/Angle.scala

@@ -36,9 +36,15 @@ final class Angle private (val value: Double, val unit: AngleUnit)
   def asin = math.asin(toRadians)
   def acos = math.acos(toRadians)
 
-  def onRadius(that: Length): Length = {
-    toRadians * that
-  }
+  /**
+    * length of the arc traveled by a point on the rim of a circle with this
+    * angle traveled and the given (constant) radius from the center of
+    * rotation
+    * @param radius the distance from the center of rotation
+    * @return arc length with given arc measure and radius
+    */
+  def onRadius(radius: Length): Length = toRadians * radius
+
 
   protected def timeDerived: AngularVelocity = RadiansPerSecond(toRadians)
 

shared/src/test/scala/squants/mass/MomentOfInertiaSpec.scala

@@ -0,0 +1,77 @@
+package squants.mass
+
+import org.scalatest.{FlatSpec, Matchers}
+import squants.CustomMatchers
+import squants.motion.{AngularAccelerationConversions, NewtonMeters, RadiansPerSecondSquared}
+import squants.space.{Feet, Meters}
+
+/**
+  *
+  * @author paxelord
+  * @since 1.2
+  **/
+class MomentOfInertiaSpec extends FlatSpec with Matchers with CustomMatchers {
+
+  behavior of "MomentOfInertia and its Units of Measure"
+
+  val unitValueSi = KilogramsMetersSquared(1)
+
+  it should "create values using UOM factories" in {
+    KilogramsMetersSquared(10.22).toKilogramsMetersSquared should be(10.22)
+    PoundsSquareFeet(10.22).toPoundsSquareFeet should be(10.22)
+  }
+
+  it should "create values from properly formatted Strings" in {
+    MomentOfInertia("10.22 kg‧m²").get should be(KilogramsMetersSquared(10.22))
+    MomentOfInertia("10.22 lb‧ft²").get should be(PoundsSquareFeet(10.22))
+  }
+
+  it should "properly convert to all supported Units of Measure" in {
+    implicit val tolerance = 1e-10
+    val a = KilogramsMetersSquared(1)
+
+    val kilogramsToPounds = 1D / Pounds.conversionFactor
+    val metersToFeet = 1D / Feet.conversionFactor
+    a.toPoundsSquareFeet should beApproximately(kilogramsToPounds * metersToFeet * metersToFeet)
+
+    val b = PoundsSquareFeet(1)
+    val poundsToKilograms = Pounds.conversionFactor
+    val feetToMeters = Feet.conversionFactor
+    b.toKilogramsMetersSquared should beApproximately(poundsToKilograms * feetToMeters * feetToMeters)
+  }
+
+  it should "return properly formatted strings for all supported Units of Measure" in {
+    PoundsSquareFeet(1).toString(PoundsSquareFeet) should be("1.0 lb‧ft²")
+    unitValueSi.toString(KilogramsMetersSquared) should be("1.0 kg‧m²")
+  }
+
+  it should "return Torque when multiplied by AngularAcceleration" in {
+    unitValueSi * RadiansPerSecondSquared(1) should be(NewtonMeters(1))
+  }
+
+  it should "return mass when atCenter is called" in {
+    unitValueSi atCenter Meters(1) should be(Kilograms(1))
+  }
+
+  it should "provide aliases for single unit values" in {
+    import MomentOfInertiaConversions._
+
+    poundSquareFeet should be(PoundsSquareFeet(1))
+    kilogramMetersSquared should be(KilogramsMetersSquared(1))
+  }
+
+  it should "provide implicit conversion from Double" in {
+    import MomentOfInertiaConversions._
+
+    val d = 10.22
+    d.kilogramMetersSquared should be(KilogramsMetersSquared(d))
+    d.poundSquareFeet should be(PoundsSquareFeet(d))
+  }
+
+  it should "provide Numeric support" in {
+    import MomentOfInertiaConversions._
+
+    val momentOfInertiaList = List(KilogramsMetersSquared(100), KilogramsMetersSquared(10))
+    momentOfInertiaList.sum should be(KilogramsMetersSquared(110))
+  }
+}

shared/src/test/scala/squants/motion/AngularAccelerationSpec.scala

@@ -0,0 +1,83 @@
+package squants.motion
+
+import org.scalatest.{FlatSpec, Matchers}
+import squants.QuantityParseException
+import squants.space.{Meters, Radians}
+import squants.time.Seconds
+
+/**
+  *
+  * @author paxelord
+  * @since 1.2
+  */
+class AngularAccelerationSpec extends FlatSpec with Matchers{
+
+  behavior of "AngularAcceleration and its Units of Measure"
+
+  it should "create values using UOM factories" in {
+    RadiansPerSecondSquared(1).toRadiansPerSecondSquared should be(1)
+    DegreesPerSecondSquared(1).toDegreesPerSecondSquared should be(1)
+    GradsPerSecondSquared(1).toGradsPerSecondSquared should be(1)
+    TurnsPerSecondSquared(1).toTurnsPerSecondSquared should be(1)
+  }
+
+  it should "create values from properly formatted Strings" in {
+    AngularAcceleration("10.22 rad/s²").get should be(RadiansPerSecondSquared(10.22))
+    AngularAcceleration("10.22 °/s²").get should be(DegreesPerSecondSquared(10.22))
+    AngularAcceleration("10.22 grad/s²").get should be(GradsPerSecondSquared(10.22))
+    AngularAcceleration("10.22 turns/s²").get should be(TurnsPerSecondSquared(10.22))
+    AngularAcceleration("10.22 zz").failed.get should be(QuantityParseException("Unable to parse AngularAcceleration", "10.22 zz"))
+    AngularAcceleration("zz rad/s²").failed.get should be(QuantityParseException("Unable to parse AngularAcceleration", "zz rad/s²"))
+  }
+
+  it should "properly convert to all supported Units of Measure" in {
+    val x = RadiansPerSecondSquared(1)
+    x.toRadiansPerSecondSquared should be(1)
+    x.toDegreesPerSecondSquared should be(Radians(1).toDegrees)
+    x.toGradsPerSecondSquared should be(Radians(1).toGradians)
+    x.toTurnsPerSecondSquared should be(Radians(1).toTurns)
+  }
+
+  it should "return properly formatted strings for all supported Units of Measure" in {
+    RadiansPerSecondSquared(1).toString(RadiansPerSecondSquared) should be("1.0 rad/s²")
+    DegreesPerSecondSquared(1).toString(DegreesPerSecondSquared) should be("1.0 °/s²")
+    GradsPerSecondSquared(1).toString(GradsPerSecondSquared) should be("1.0 grad/s²")
+    TurnsPerSecondSquared(1).toString(TurnsPerSecondSquared) should be("1.0 turns/s²")
+  }
+
+  it should "return AnglularVelocity when multiplied by Time" in {
+    RadiansPerSecondSquared(1) * Seconds(1) should be(RadiansPerSecond(1))
+  }
+
+  it should "return Acceleration of particle onRadius of AngularAcceleration" in {
+    RadiansPerSecondSquared(1) onRadius Meters(1) should be(MetersPerSecondSquared(1))
+  }
+
+  behavior of "AngularAccelerationConversions"
+
+  it should "provide aliases for single unit values" in {
+    import AngularAccelerationConversions._
+
+    radianPerSecondSquared should be(RadiansPerSecondSquared(1))
+    degreePerSecondSquared should be(DegreesPerSecondSquared(1))
+    gradPerSecondSquared should be(GradsPerSecondSquared(1))
+    turnPerSecondSquared should be(TurnsPerSecondSquared(1))
+  }
+
+  it should "provide implicit conversion from Double" in {
+    import AngularAccelerationConversions._
+
+    val d = 10.22d
+    d.radiansPerSecondSquared should be(RadiansPerSecondSquared(d))
+    d.degreesPerSecondSquared should be(DegreesPerSecondSquared(d))
+    d.gradsPerSecondSquared should be(GradsPerSecondSquared(d))
+    d.turnsPerSecondSquared should be(TurnsPerSecondSquared(d))
+  }
+
+  it should "provide Numeric support" in {
+    import AngularAccelerationConversions.AngularAccelerationNumeric
+
+    val aas = List(RadiansPerSecondSquared(100), RadiansPerSecondSquared(10))
+    aas.sum should be(RadiansPerSecondSquared(110))
+  }
+}