satkit 0.2.9__tar.gz → 0.3.0__tar.gz

{satkit-0.2.9 → satkit-0.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satkit"
-version = "0.2.9"
+version = "0.3.0"
 edition = "2021"
 description = "Satellite Toolkit"
 readme = "README.md"
@@ -20,25 +20,25 @@ name = "satkit"
 
 
 [dependencies]
-nalgebra = "0.32.3"
+nalgebra = "0.33.0"
 ndarray = "0.15.6"
 libc = "0.2"
 chrono = "0.4.19"
 cty = "0.2.2"
 num-traits = "0.2"
 thiserror = "1.0"
-simba = "0.8"
+simba = "0.9"
 once_cell = "1.6.0"
 numpy = { version = "0.21.0", optional = true }
-pyo3 = { version = "0.21.0", features = ["extension-module"], optional = true }
+pyo3 = { version = "0.21", features = ["extension-module"], optional = true }
 ureq = "2.9.1"
 json = "0.12.4"
 process_path = "0.1.4"
 
 [build-dependencies]
 cc = { version = "1.0.74", features = ["parallel"] }
-chrono = "0.4.19"
-pyo3-build-config = { version = "0.21.0", optional = true }
+chrono = "0.4.38"
+pyo3-build-config = { version = "0.21", optional = true }
 
 [dev-dependencies]
 rand = "0.8.5"

{satkit-0.2.9/python/satkit.egg-info → satkit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.2.9
+Version: 0.3.0
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>

{satkit-0.2.9 → satkit-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "satkit"
-version = "0.2.9"
+version = "0.3.0"
 dependencies = ["numpy>=1.20.0"]
 requires-python = ">= 3.8"
 authors = [{ name = "Steven Michael", email = "ssmichael@gmail.com" }]

{satkit-0.2.9 → satkit-0.3.0}/python/docs/source/conf.py

@@ -77,8 +77,8 @@ github_project_url = "https://github.com/ssmichael1/satkit"
 ##version = "%i.%i" % version_ns["version_info"][:2]
 # The full version, including alpha/beta/rc tags.
 ##release = version_ns["__version__"]
-version = "0.2.7"
-release = "0.2.7"
+version = "0.2.9"
+release = "0.2.9"
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -162,7 +162,7 @@ html_theme = "sphinx_rtd_theme"
 # NOTE: Sphinx's 'make html' builder will throw a warning about an unfound
 #       _static directory. Do not remove or comment out html_static_path
 #       since it is needed to properly generate _static in the build directory
-html_static_path = ["source/_static"]
+html_static_path = ["_static"]
 
 # Add any extra paths that contain custom files (such as robots.txt or
 # .htaccess) here, relative to this directory. These files are copied
@@ -324,5 +324,5 @@ intersphinx_mapping = {
 spelling_lang = "en_US"
 spelling_word_list_filename = "spelling_wordlist.txt"
 
-primary_domain = "python"
+# primary_domain = "python"
 highlight_language = "python"

{satkit-0.2.9 → satkit-0.3.0}/python/satkit/__init__.pyi

@@ -31,6 +31,7 @@ __all__ = [
     "sun",
     "planets",
     "satprop",
+    "satstate",
     "density",
-    "utils"
+    "utils",
 ]

{satkit-0.2.9 → satkit-0.3.0}/python/satkit/density.pyi

@@ -22,22 +22,16 @@ def nrlmsise(itrf: satkit.itrfcoord, time: satkit.time | None) -> typing.Tuple[f
     or for more detail:
     https://agupubs.onlinelibrary.wiley.com/doi/full/10.1029/2002JA009430
     
-    Inputs: 
+    Args: 
     
-        itrf:  satkit.itrfcoord representing position at which to 
-                compute density & temperature
-                  
-        time:  Optional instant at which to compute density & temperature.
+        itrf (satkit.itrfcoord):  position at which to compute density & temperature                  
+        time (satkit.time|numpy.ndarray|list):  Optional instant(s) at which to compute density & temperature.
                "Space weather" data at this time will be used in model 
                computation.  Note: at satellite altitudes, density can
                change by > 10 X depending on solar cycle
                  
-    Outputs:
-        
-        rho:  Atmosphere mass density in kg / m^3
-        
-          T:  Atmosphere temperature in Kelvin
-    
+    Returns:
+        tuple: (rho, T) where rho is mass density in kg/m^3 and T is temperature in Kelvin
     """
     
 @typing.overload
@@ -53,22 +47,15 @@ def nrlmsise(altitude_meters: float,
     or for more detail:
     https://agupubs.onlinelibrary.wiley.com/doi/full/10.1029/2002JA009430
     
-    Inputs: 
-    
-    altitude_meters:  Altitude in meters
-    
-       latitude_rad:  Latitude in radians
-       
-      longitude_rad:  Longitude in radians
+    Args:
+        altitude_meters (float):  Altitude in meters
+        latitude_rad (float, optional):  Latitude in radians. Default is 0.
+        longitude_rad (float, optional):  Longitude in radians.  Default is 0.
+        time (satkit.time|numpy.ndarray|list, optional):  Optional instant(s) at which to compute density & temperature.
+               "Space weather" data at this time will be used in model 
+               computation.  Note: at satellite altitudes, density can
+               change by > 10 X depending on solar cycle
                  
-               time:  Optional instant at which to compute density & temperature.
-                      "Space weather" data at this time will be used in model 
-                      computation.  Note: at satellite altitudes, density can
-                      change by > 10 X depending on solar cycle                 
-    Outputs:
-        
-        rho:  Atmosphere mass density in kg / m^3
-        
-          T:  Atmosphere temperature in Kelvin
-    
+    Returns:
+        tuple: (rho, T) where rho is mass density in kg/m^3 and T is temperature in Kelvin
     """

{satkit-0.2.9 → satkit-0.3.0}/python/satkit/satkit.pyi

@@ -454,15 +454,17 @@ class time:
     
     Notes:
         * If no arguments are passed in, the created object represents the current time
-    
+        * If year is passed in, month and day must also be passed in
+        * If hour is passed in, minute and second must also be passed in
+
     Args:
-        year (int): Gregorian year (e.g., 2024) (optional)
-        month (int): Gregorian month (1 = January, 2 = February, ...) (optional)
-        day (int): Day of month, beginning with 1 (optional)
-        hour (int): Hour of day, in range [0,23] (optional), default is 0
-        min (int): Minute of hour, in range [0,59] (optional), default is 0
-        sec (float): floating point second of minute, in range [0,60) (optional), defialt is 0
-        scale (satkit.timescale): Time scale (optional), default is satkit.timescale.UTC    
+        year (int, optional): Gregorian year (e.g., 2024)
+        month (int, optional): Gregorian month (1 = January, 2 = February, ...)
+        day (int, optional): Day of month, beginning with 1
+        hour (int, optional): Hour of day, in range [0,23] (optional), default is 0
+        min (int, optional): Minute of hour, in range [0,59], default is 0
+        sec (float, optional): floating point second of minute, in range [0,60), default is 0
+        scale (satkit.timescale, optional): Time scale , default is satkit.timescale.UTC    
     
     Returns:
         satkit.time: Time object representing input date and time, or if no arguments, the current date and time
@@ -488,13 +490,13 @@ class time:
             * If no arguments are passed in, the created object represents the current time
         
         Args:
-            year (int): Gregorian year (e.g., 2024) (optional)
-            month (int): Gregorian month (1 = January, 2 = February, ...) (optional)
-            day (int): Day of month, beginning with 1 (optional)
-            hour (int): Hour of day, in range [0,23] (optional), default is 0
-            min (int): Minute of hour, in range [0,59] (optional), default is 0
-            sec (float): floating point second of minute, in range [0,60) (optional), defialt is 0
-            scale (satkit.timescale): Time scale (optional), default is satkit.timescale.UTC    
+            year (int, optional): Gregorian year (e.g., 2024)
+            month (int, optional): Gregorian month (1 = January, 2 = February, ...)
+            day (int, optional): Day of month, beginning with 1
+            hour (int, optional): Hour of day, in range [0,23] (optional), default is 0
+            min (int, optional): Minute of hour, in range [0,59], default is 0
+            sec (float, optional): floating point second of minute, in range [0,60), default is 0
+            scale (satkit.timescale, optional): Time scale , default is satkit.timescale.UTC   
         
         Returns:
             satkit.time: Time object representing input date and time, or if no arguments, the current date and time
@@ -541,6 +543,17 @@ class time:
             satkit.time: Time object representing input Julian date and time scale
         """
 
+    @staticmethod
+    def from_unixtime(ut: float) -> time:
+        """Return a time object representing input unixtime
+        
+        Args:
+            ut (float): unixtime, UTC seconds since Jan 1, 1970 00:00:00
+
+        Returns:
+            satkit.time: Time object representing input unixtime
+        """
+
     @staticmethod
     def from_mjd(mjd: float, scale: timescale = timescale.UTC) -> time:
         """Return a time object representing input modified Julian date and time scale
@@ -1125,11 +1138,6 @@ class kepler:
         """Mean anomaly, radians
         """
 
-    @property
-    def mean_motion(self) -> float:
-        """Mean motion, radians / second
-        """
-
     @property
     def period(self) -> float:
         """Orbital period, seconds
@@ -1406,3 +1414,85 @@ class consts:
     def jgm3_j2() -> float:
         """ "J2" gravity due oblateness of Earth from JGM3 gravity model, unitless
         """
+class satstate:
+    """
+    A convenience class representing a satellite position and velocity, and
+    optionally 6x6 position/velocity covariance at a particular instant in time
+
+    This class can be used to propagate the position, velocity, and optional
+    covariance to different points in time.
+    """
+
+    def __init__(
+        self,
+        time: time,
+        pos: npt.ArrayLike[np.float64],
+        vel: npt.ArrayLike[np.float64],
+        cov: npt.ArrayLike[np.float64] | None = None,
+    ):
+        """Create a new satellite state
+
+        Args:
+            time (satkit.time): Time instant of this state
+            pos (npt.ArrayLike[np.float64]): Position in meters in GCRF frame
+            vel (npt.ArrayLike[np.float64]): Velocity in meters / second in GCRF frame
+            cov (npt.ArrayLike[np.float64]|None, optional): Covariance in GCRF frame. Defaults to None.  If input, should be a 6x6 numpy array
+        
+        Returns:
+            satstate: New satellite state object
+        """
+
+    @property
+    def pos_gcrf(self) -> npt.ArrayLike[np.float64]:
+        """state position in meters in GCRF frame
+        
+        Returns:
+            npt.ArrayLike[np.float64]: 3-element numpy array representing position in meters in GCRF frame
+        """
+
+    @property
+    def vel_gcrf(self) -> npt.ArrayLike[np.float64]:
+        """Return this state velocity in meters / second in GCRF
+
+        Returns:
+            npt.ArrayLike[np.float64]: 3-element numpy array representing velocity in meters / second in GCRF frame
+        """
+
+    @property
+    def qgcrf2lvlh(self) -> quaternion:
+        """ Quaternion that rotates from the GCRF to the LVLH frame for the current state
+
+        Returns:
+            satkit.quaternion: Quaternion that rotates from the GCRF to the LVLH frame for the current state
+        """
+
+
+    @property
+    def cov(self) -> npt.ArrayLike[np.float64] | None:
+        """6x6 state covariance matrix in GCRF frame
+        
+        Returns:
+            npt.ArrayLike[np.float64] | None: 6x6 numpy array representing state covariance in GCRF frame or None if not set
+        """
+
+
+    @property
+    def time(self) -> time:
+        """Return time of this satellite state
+        
+        Returns:
+            satkit.time: Time instant of this state
+        """
+
+    def propagate(self, time: time | duration, propsettings=None) -> satstate:
+        """Propagate this state to a new time, specified by the "time" input, updating the position, the velocity, and the covariance if set
+
+        Args:
+            time (satkit.time|satkit.duration): Time or duration from current time to which to propagate the state
+
+        Keyword Arguments:
+            propsettings: satkit.satprop.propsettings object describing settings to use in the propagation. If omitted, default is used 
+
+        Returns:
+            satstate: New satellite state object representing the state at the new time
+        """

{satkit-0.2.9 → satkit-0.3.0}/python/satkit/satprop.pyi

@@ -38,134 +38,65 @@ import numpy as np
 import satkit
 import datetime
 
-class PropStats(typing.TypedDict):
-    """PropStats is a dictionary containing statistics for the propagation.
-    """
-    
-    num_eval: int
-    """int: Number of function evaluations of the force model computed during propagation function call
-    """
+class propstats:
+    @property
+    def num_eval() -> int:
+        """Number of function evaluations"""
 
-    accepted_steps: int
-    """int: Accepted steps in the adaptive Runga-Kutta solver
-    """
-    
-    rejected_steps: int
-    """int: Rejected steps in the adaptive Runga-Kutta solver
-    """
+    @property
+    def num_accept() -> int:
+        """Number of accepted steps in adaptive RK integrator"""
 
-class PropResult(typing.TypedDict):
-    """
-    PropResult is a dictionary containing the results of a high-precision orbit propagation that is returned by the "propagate" function
-    """
+    @property
+    def num_reject() -> int:
+        """Number of rejected steps in adaptive RK integrator"""
 
-    time: npt.ArrayLike[satkit.time]
-    """npt.ArrayLike[satkit.time]: List of satkit.time objects at which time is computed
-    """
+class propresult:
+    """Results of a satellite propagation
     
-    pos: npt.ArrayLike[np.float64]
-    """npt.ArrayLike[float]: GCRF position in meters at output times.  Output is Nx3 numpy matrix, where N is the number of times
-    """
-
-    vel: npt.ArrayLike[np.float64]
-    """npt.ArrayLike[float]: GCRF velocity in meters per second at output times.  Output is Nx3 numpy matrix, where N is the number of times
-    """
-
-    Phi: typing.NotRequired[npt.ArrayLike[np.float64]]
-    """6x6 State transition matrix corresponding to each time. Output is Nx6x6 numpy matrix, where N is the lenght of the output "time" list. Not included if output_phi kwarg is set to false (the default)
-    """
-
-    stats: PropStats
-    """
-    (PropStats): Python dictionary with statistics for the propagation. This includes:
-
-            * num_eval: Number of function evaluations of the force model required to get solution with desired accuracy
-            * accepted_steps: Accepted steps in the adpative Runga-Kutta solver
-            * rejected_steps: Rejected steps in the adaptive Runga-Kutta solver
-    """
-
-class satstate:
-    """
-    A convenience class representing a satellite position and velocity, and
-    optionally 6x6 position/velocity covariance at a particular instant in time
-
-    This class can be used to propagate the position, velocity, and optional
-    covariance to different points in time.
+    This class lets the user access results of the satellite propagation
     """
 
-    def __init__(
-        self,
-        time: satkit.time,
-        pos: npt.ArrayLike[np.float64],
-        vel: npt.ArrayLike[np.float64],
-        cov: npt.ArrayLike[np.float64] | None = None,
-    ):
-        """Create a new satellite state
-
-        Args:
-            time (satkit.time): Time instant of this state
-            pos (npt.ArrayLike[np.float64]): Position in meters in GCRF frame
-            vel (npt.ArrayLike[np.float64]): Velocity in meters / second in GCRF frame
-            cov (npt.ArrayLike[np.float64]|None, optional): Covariance in GCRF frame. Defaults to None.  If input, should be a 6x6 numpy array
-        
-        Returns:
-            satstate: New satellite state object
-        """
-
     @property
-    def pos_gcrf(self) -> npt.ArrayLike[np.float64]:
-        """state position in meters in GCRF frame
-        
-        Returns:
-            npt.ArrayLike[np.float64]: 3-element numpy array representing position in meters in GCRF frame
-        """
+    def pos() -> npt.ArrayLike[float]:
+        """GCRF position of satellite, meters"""
 
     @property
-    def vel_gcrf(self) -> npt.ArrayLike[np.float64]:
-        """Return this state velocity in meters / second in GCRF
-
-        Returns:
-            npt.ArrayLike[np.float64]: 3-element numpy array representing velocity in meters / second in GCRF frame
-        """
+    def vel() -> npt.ArrayLike[float]:
+        """GCRF velocity of satellite, meters/second"""
 
     @property
-    def qgcrf2lvlh(self) -> satkit.quaternion:
-        """ Quaternion that rotates from the GCRF to the LVLH frame for the current state
-
-        Returns:
-            satkit.quaternion: Quaternion that rotates from the GCRF to the LVLH frame for the current state
-        """
-
+    def state() -> npt.ArrayLike[float]:
+        """6-element state (pos + vel) of satellite in meters & meters/second"""
 
     @property
-    def cov(self) -> npt.ArrayLike[np.float64] | None:
-        """6x6 state covariance matrix in GCRF frame
-        
-        Returns:
-            npt.ArrayLike[np.float64] | None: 6x6 numpy array representing state covariance in GCRF frame or None if not set
-        """
+    def time() -> satkit.time:
+        """Time at which state is valid"""
 
+    @property
+    def stats() -> propstats:
+        """Statistics of propagation"""
 
     @property
-    def time(self) -> satkit.time:
-        """Return time of this satellite state
-        
-        Returns:
-            satkit.time: Time instant of this state
-        """
+    def phi() -> npt.ArrayLike[np.float64]|None:
+        """6x6 State transition matrix 
+        or None if not computed
+        """        
 
-    def propagate(self, time: satkit.time|satkit.duration, propsettings=None) -> satstate:
-        """Propagate this state to a new time, specified by the "time" input, updating the position, the velocity, and the covariance if set
+    def interp(time: satkit.time, output_phi: bool=False) -> npt.ArrayLike[np.float64]|typing.Tuple[npt.ArrayLike[np.float64], npt.ArrayLike[np.float64]]:
+        """Interpolate state at given time
 
         Args:
-            time (satkit.time|satkit.duration): Time or duration from current time to which to propagate the state
+            time (satkit.time): Time at which to interpolate state
 
         Keyword Arguments:
-            propsettings: satkit.satprop.propsettings object describing settings to use in the propagation. If omitted, default is used 
+            output_phi (bool): Output 6x6 state transition matrix at the interpolated time
 
         Returns:
-            satstate: New satellite state object representing the state at the new time
+            6-element vector representing state at given time
+            if output_phi, also output 6x6 state transition matrix at given time
         """
+    
 
 class satproperties_static:
     """Satellite properties relevant for drag and radiation pressure
@@ -274,7 +205,7 @@ def propagate(
     vel: npt.ArrayLike[float],
     start: satkit.time,
     **kwargs,
-) -> PropResult:
+) -> propresult:
     """High-precision orbit propagator
 
     Notes:
@@ -302,21 +233,13 @@ def propagate(
         duration_secs (float): duration in seconds from "tm" for at which new position and velocity will be computed.
         duration_days (float): duration in days from "tm" at which new position and velocity will be computed.
         duration (satkit.duration): duration from "tm" at which new position & velocity will be computed.
-        dt_secs (float): Interval in seconds between "starttime" and "stoptime" at which solution will also be computed
-        dt_days (float): Interval in days between "starttime" and "stoptime" at which solution will also be computed
-        dt (satkit.duration): Interval over which new position & velocity will be computed
         output_phi (bool): Output 6x6 state transition matrix between "starttime" and "stoptime" (and at intervals, if specified)
         propsettings (propsettings): "propsettings" object with input settings for the propagation. if left out, default will be used.
-        satproperties (satproperties_static): "SatPropertiesStatic" object with drag and radiation pressure succeptibility of satellite. If left out, drag and radiation pressure are neglected
+        satproperties (satproperties_static): "SatPropertiesStatic" object with drag and radiation pressure succeptibility of satellite. 
+                                            If left out, drag and radiation pressure are neglected
+        output_dense: boolean indicting whether or not dense output should be recorded.  Default is false.  If true, this will allow for calling the "interp" function
+                      to query states at arbitrary times between the start time and the stop time
 
     Returns:
-        (PropResult): Python dictionary with the following elements:
-            * "time": list of satkit.time objects at which solution is computed
-            * "pos": GCRF position in meters at "time".  Output is a Nx3 numpy matrix, where N is the length of the output "time" list
-            * "vel": GCRF velocity in meters / second at "time".  Output is a Nx3 numpy matrix, where N is the length of the output "time" list
-            *  "Phi": 6x6 State transition matrix corresponding to each time. Output is Nx6x6 numpy matrix, where N is the lenght of the output "time" list. Not included if output_phi kwarg is set to false (the default)
-            * "stats": Python dictionary with statistics for the propagation. This includes:
-                * "num_eval": Number of function evaluations of the force model required to get solution with desired accuracy
-                * "accepted_steps": Accepted steps in the adpative Runga-Kutta solver
-                * "rejected_steps": Rejected steps in the adaptive Runga-Kutta solver
+        (propresult): Propagation result object holding state outputs, statistics, and dense output if requested
     """

{satkit-0.2.9 → satkit-0.3.0/python/satkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.2.9
+Version: 0.3.0
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>

{satkit-0.2.9 → satkit-0.3.0}/python/satkit.egg-info/SOURCES.txt

@@ -90,6 +90,7 @@ src/pybindings/pylpephem_planets.rs
 src/pybindings/pylpephem_sun.rs
 src/pybindings/pynrlmsise.rs
 src/pybindings/pypropagate.rs
+src/pybindings/pypropresult.rs
 src/pybindings/pypropsettings.rs
 src/pybindings/pyquaternion.rs
 src/pybindings/pysatproperties.rs

{satkit-0.2.9 → satkit-0.3.0}/python/test/test.py

@@ -607,16 +607,18 @@ class TestHighPrecisionPropagation:
             np.array([2.47130555e03, 2.94682777e03, -5.34171918e02]),
             timearr[0],
             stoptime=timearr[-1],
-            dt=sk.duration.from_minutes(5),
             propsettings=settings,
             satproperties=satprops,
+            output_dense=True,
         )
+        print(res)
 
         # See if propagator is accurate to < 10 meters over 1 day on
         # each Cartesian axis
-        for iv in range(pgcrf.shape[0]):
+        for iv in range(pgcrf.shape[0]-5):            
+            state = res.interp(timearr[iv])
             for ix in range(0, 3):
-                assert m.fabs(res["pos"][iv, ix] - pgcrf[iv, ix]) < 10
+                assert m.fabs(state[ix] - pgcrf[iv, ix]) < 10
 
 class TestSatState:
     def test_lvlh(self):
@@ -624,8 +626,8 @@ class TestSatState:
         Test rotations of satellite state into the LVLH frame
         """
         time = sk.time(2015, 3, 20, 0, 0, 0)
-        satstate = sk.satprop.satstate(time,
-                                       np.array([sk.consts.geo_r, 0, 0]),
+        satstate = sk.satstate(time,
+                               np.array([sk.consts.geo_r, 0, 0]),
         np.array([0, m.sqrt(sk.consts.mu_earth/sk.consts.geo_r), 0]))
         state2 = satstate.propagate(time + sk.duration.from_hours(3.5))
         h =np.cross(state2.pos, state2.vel)

{satkit-0.2.9 → satkit-0.3.0}/src/astrotime.rs

@@ -37,7 +37,7 @@
 //!
 #[derive(PartialEq, PartialOrd, Copy, Clone, Debug)]
 pub struct AstroTime {
-    mjd_tai: f64,
+    pub(crate) mjd_tai: f64,
 }
 
 use crate::utils::{download_if_not_exist, skerror, SKResult};
@@ -92,7 +92,7 @@ const DELTAAT_OLD: [[f64; 4]; 15] = [
 /// Time Scales
 ///
 /// # Enum Values:
-/// 
+///
 /// * `UTC` - Univeral Time Coordiante
 /// * `TT` - Terrestrial Time
 /// * `UT1` - UT1

{satkit-0.2.9 → satkit-0.3.0}/src/duration.rs

@@ -66,6 +66,7 @@ impl Duration {
         }
     }
 
+    /// String representation of duration
     pub fn to_string(&self) -> String {
         let mut secs = self.seconds();
         let mut sign = String::from("");
@@ -77,7 +78,7 @@ impl Duration {
         // e.g. if seconds = 59.999..., rather than round up and
         // display "seconds" in second field, show 0 and increment
         // minutes...
-        if secs % 60.0  > 59.9995 {
+        if secs % 60.0 > 59.9995 {
             secs = secs + 5.0e-4;
         }