No-std actually works now.

Lack of float traits is a real pain!

Author: thejpster

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "measurements"
-version = "0.9.0"
+version = "0.10.0"
 authors = ["James O'Cull <[email protected]>",
           "Jonathan Pallant <[email protected]>",
           "Hannah McLaughlin <[email protected]>",
@@ -13,6 +13,5 @@ description = "Handle metric, imperial, and other measurements with ease! Types:
 license = "MIT"
 readme = "README.md"
 
-
-[dependencies]
-time = "0.1"
+[features]
+no_std = []

src/acceleration.rs

@@ -9,16 +9,15 @@ use super::length;
 /// # Example
 ///
 /// ```
-/// extern crate time;
 /// extern crate measurements;
 /// use measurements::{Acceleration, Length, Speed};
-/// use time::Duration;
+/// use std::time::Duration;
 ///
 /// fn main() {
 ///     // Standing quarter mile in 10.0 dead, at 120.0 mph
 ///     let track = Length::from_miles(0.25);
 ///     let finish = Speed::from_miles_per_hour(120.0);
-///     let time = Duration::seconds(10);
+///     let time = Duration::new(10, 0);
 ///     let accel: Acceleration = finish / time;
 ///     println!("You accelerated over {} at an average of {}", track, accel);
 ///}
@@ -85,14 +84,13 @@ mod test {
 
     use super::*;
     use test_utils::assert_almost_eq;
-    use time::Duration;
     use speed::Speed;
 
     // Metric
     #[test]
     fn speed_over_time() {
         let s1 = Speed::from_meters_per_second(10.0);
-        let t1 = Duration::seconds(5);
+        let t1 = ::time::Duration::new(5, 0);
         let i1 = s1 / t1;
         let r1 = i1.as_meters_per_second_per_second();
         assert_almost_eq(r1, 2.0);
@@ -159,5 +157,4 @@ mod test {
         assert_eq!(a > b, false);
         assert_eq!(a >= b, false);
     }
-
 }

src/angle.rs

@@ -22,7 +22,7 @@ pub struct Angle {
 impl Angle {
     /// Create a new Angle from a floating point value in degrees
     pub fn from_degrees(degrees: f64) -> Self {
-        Angle::from_radians(degrees.to_radians())
+        Angle::from_radians(degrees * ::PI / 180.0)
     }
 
     /// Create a new Angle from a floating point value in radians
@@ -32,7 +32,7 @@ impl Angle {
 
     /// Convert this Angle to a floating point value in degrees
     pub fn as_degrees(&self) -> f64 {
-        self.radians.to_degrees()
+        self.radians * 180.0 / ::PI
     }
 
     /// Convert this Angle to a floating point value in radians
@@ -41,36 +41,43 @@ impl Angle {
     }
 
     /// Calculate the cosine of this angle
+    #[cfg(not(feature = "no_std"))]
     pub fn cos(&self) -> f64 {
         self.radians.cos()
     }
 
     /// Calculate the sine of this angle
+    #[cfg(not(feature = "no_std"))]
     pub fn sin(&self) -> f64 {
         self.radians.sin()
     }
 
     /// Calculate the sine and cosine of this angle
+    #[cfg(not(feature = "no_std"))]
     pub fn sin_cos(&self) -> (f64, f64) {
         self.radians.sin_cos()
     }
 
     /// Calculate the tangent of this angle
+    #[cfg(not(feature = "no_std"))]
     pub fn tan(&self) -> f64 {
         self.radians.tan()
     }
 
     /// Calculate the arcsine of a number
+    #[cfg(not(feature = "no_std"))]
     pub fn asin(num: f64) -> Self {
         Angle::from_radians(num.asin())
     }
 
     /// Calculate the arccosine of a number
+    #[cfg(not(feature = "no_std"))]
     pub fn acos(num: f64) -> Self {
         Angle::from_radians(num.acos())
     }
 
     /// Calculate the arctangent of a number
+    #[cfg(not(feature = "no_std"))]
     pub fn atan(num: f64) -> Self {
         Angle::from_radians(num.atan())
     }
@@ -95,7 +102,7 @@ implement_measurement! { Angle }
 #[cfg(test)]
 mod test {
     use angle::*;
-    use core::f64::consts::PI;
+    use std::f64::consts::PI;
     use test_utils::assert_almost_eq;
 
     #[test]

src/angular_velocity.rs

@@ -1,7 +1,7 @@
 //! Types and constants for handling speed of rotation (angular velocity)
 
 use super::measurement::*;
-use core::f64::consts::PI;
+use ::PI;
 
 /// The 'AngularVelocity' struct can be used to deal with angular velocities in a common way.
 ///

src/data.rs

@@ -155,11 +155,11 @@ impl Measurement for Data {
         let list = [
             ("octets", 1.0),
             ("KiB", 1024.0),
-            ("MiB", 1024.0_f64.powi(2)),
-            ("GiB", 1024.0_f64.powi(3)),
-            ("TiB", 1024.0_f64.powi(4)),
-            ("PiB", 1024.0_f64.powi(5)),
-            ("EiB", 1024.0_f64.powi(6)),
+            ("MiB", 1024.0 * 1024.0),
+            ("GiB", 1024.0 * 1024.0 * 1024.0),
+            ("TiB", 1024.0 * 1024.0 * 1024.0 * 1024.0),
+            ("PiB", 1024.0 * 1024.0 * 1024.0 * 1024.0 * 1024.0),
+            ("EiB", 1024.0 * 1024.0 * 1024.0 * 1024.0 * 1024.0 * 1024.0),
         ];
         self.pick_appropriate_units(&list)
     }

src/frequency.rs

@@ -1,6 +1,7 @@
 //! Types and constants for handling frequencies.
 
 use super::measurement::*;
+use ::time;
 
 /// Number of nanohertz in a Hz
 pub const HERTZ_NANOHERTZ_FACTOR: f64 = 1e9;
@@ -78,7 +79,7 @@ impl Frequency {
     }
 
     /// Create a new Frequency from a floating point value of the period in seconds.
-    pub fn from_period(period: ::time::Duration) -> Self {
+    pub fn from_period(period: time::Duration) -> Self {
         Self::from_hertz(1.0 / period.as_base_units())
     }
 
@@ -123,8 +124,8 @@ impl Frequency {
     }
 
     /// Convert this Frequency to a floating point value of the period in seconds.
-    pub fn as_period(&self) -> ::time::Duration {
-        ::time::Duration::from_base_units(1.0 / self.hertz)
+    pub fn as_period(&self) -> time::Duration {
+        time::Duration::from_base_units(1.0 / self.hertz)
     }
 }
 
@@ -163,6 +164,7 @@ implement_measurement! { Frequency }
 mod test {
     use super::*;
     use test_utils::assert_almost_eq;
+    use ::time;
 
     #[test]
     pub fn hertz() {
@@ -245,7 +247,7 @@ mod test {
     pub fn period() {
         let i1 = Frequency::from_hertz(100.0);
         let r1 = i1.as_period().as_base_units();
-        let i2 = Frequency::from_period(::time::Duration::seconds(100));
+        let i2 = Frequency::from_period(time::Duration::new(100, 0));
         let r2 = i2.as_hertz();
         assert_almost_eq(r1, 1e-2);
         assert_almost_eq(r2, 1e-2);

src/lib.rs

@@ -7,9 +7,18 @@
 //! by an Area to get a Pressure.
 
 #![deny(warnings, missing_docs)]
-#![no_std]
 
-extern crate time;
+#![cfg_attr(feature="no_std", no_std)]
+
+#[cfg(feature = "no_std")]
+use core as std;
+#[cfg(feature = "no_std")]
+use core::time as time;
+
+#[cfg(not(feature = "no_std"))]
+use std::time as time;
+
+use std::f64::consts::PI as PI;
 
 #[macro_use]
 mod measurement;
@@ -76,6 +85,8 @@ mod torque_energy;
 pub use torque_energy::TorqueEnergy;
 
 pub mod prelude;
+
+#[cfg(test)]
 pub mod test_utils;
 
 /// For given types A, B and C, implement, using base units:
@@ -85,15 +96,15 @@ pub mod test_utils;
 ///     - C = A / B
 macro_rules! impl_maths {
     ($a:ty, $b:ty) => {
-        impl ::core::ops::Mul<$b> for $b {
+        impl std::ops::Mul<$b> for $b {
             type Output = $a;
 
             fn mul(self, rhs: $b) -> Self::Output {
                 Self::Output::from_base_units(self.as_base_units() * rhs.as_base_units())
             }
         }
 
-        impl ::core::ops::Div<$b> for $a {
+        impl std::ops::Div<$b> for $a {
             type Output = $b;
 
             fn div(self, rhs: $b) -> Self::Output {
@@ -103,31 +114,31 @@ macro_rules! impl_maths {
     };
 
     ($a:ty, $b:ty, $c:ty) => {
-        impl ::core::ops::Mul<$b> for $c {
+        impl std::ops::Mul<$b> for $c {
             type Output = $a;
 
             fn mul(self, rhs: $b) -> Self::Output {
                 Self::Output::from_base_units(self.as_base_units() * rhs.as_base_units())
             }
         }
 
-        impl ::core::ops::Mul<$c> for $b {
+        impl std::ops::Mul<$c> for $b {
             type Output = $a;
 
             fn mul(self, rhs: $c) -> Self::Output {
                 Self::Output::from_base_units(self.as_base_units() * rhs.as_base_units())
             }
         }
 
-        impl ::core::ops::Div<$c> for $a {
+        impl std::ops::Div<$c> for $a {
             type Output = $b;
 
             fn div(self, rhs: $c) -> Self::Output {
                 Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
             }
         }
 
-        impl ::core::ops::Div<$b> for $a {
+        impl std::ops::Div<$b> for $a {
             type Output = $c;
 
             fn div(self, rhs: $b) -> Self::Output {
@@ -139,11 +150,13 @@ macro_rules! impl_maths {
 
 impl Measurement for time::Duration {
     fn as_base_units(&self) -> f64 {
-        (self.num_microseconds().unwrap() as f64) / 1e6
+        self.as_secs() as f64 + (f64::from(self.subsec_nanos()) * 1e-9)
     }
 
     fn from_base_units(units: f64) -> Self {
-        time::Duration::microseconds((units * 1e6) as i64)
+        let subsec_nanos = ((units * 1e9) % 1e9) as u32;
+        let secs = units as u64;
+        time::Duration::new(secs, subsec_nanos)
     }
 
     fn get_base_units_name(&self) -> &'static str {
@@ -171,34 +184,35 @@ impl_maths!(TorqueEnergy, Force, Length);
 // Implement the divisions manually (the above macro only implemented the
 // TorqueEnergy / X operations).
 
-impl ::core::ops::Div<Length> for Torque {
+impl std::ops::Div<Length> for Torque {
     type Output = Force;
 
     fn div(self, rhs: Length) -> Self::Output {
         Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
     }
 }
 
-impl ::core::ops::Div<Force> for Torque {
+impl std::ops::Div<Force> for Torque {
     type Output = Length;
 
     fn div(self, rhs: Force) -> Self::Output {
         Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
     }
 }
 
-impl ::core::ops::Div<Length> for Energy {
+impl std::ops::Div<Length> for Energy {
     type Output = Force;
 
     fn div(self, rhs: Length) -> Self::Output {
         Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
     }
 }
 
-impl ::core::ops::Div<Force> for Energy {
+impl std::ops::Div<Force> for Energy {
     type Output = Length;
 
     fn div(self, rhs: Force) -> Self::Output {
         Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
     }
 }
+