|
|
#!/usr/local/midas/bin/python
|
|
|
|
|
|
"""PrecisionTime.py is a collection of python classes to manipulate times with high
|
|
|
precision using integer logic.
|
|
|
|
|
|
Written by "Bill Rideout":mailto:wrideout@haystack.mit.edu May 24, 2007
|
|
|
|
|
|
$Id$
|
|
|
"""
|
|
|
import types
|
|
|
|
|
|
class nsTime:
|
|
|
"""nsTime is a class to handle times given as UT second (integer) and nanosecond (integer)
|
|
|
|
|
|
If nanosecond > 1E9, seconds will be added to second
|
|
|
"""
|
|
|
|
|
|
def __init__(self, second, nanosecond):
|
|
|
self.second = int(second)
|
|
|
if self.second < 0:
|
|
|
raise ValueError('seconds must be greater than 0, not %i' % (self.second))
|
|
|
nanosecond = int(nanosecond)
|
|
|
if nanosecond < 0:
|
|
|
raise ValueError('nanoseconds must be greater 0, not %i' % (nanosecond))
|
|
|
addSec = nanosecond / 1000000000
|
|
|
if addSec > 0:
|
|
|
self.second += addSec
|
|
|
self.nanosecond = nanosecond % 1000000000
|
|
|
self.totalNS = int(self.nanosecond) + int(self.second) * 1000000000
|
|
|
|
|
|
|
|
|
def __add__(self, other):
|
|
|
"""__add__ another nsTime to this one and return a new one as result
|
|
|
"""
|
|
|
nsResult = self.nanosecond + other.nanosecond
|
|
|
addSec = int(nsResult / 1000000000)
|
|
|
newSec = self.second + other.second + addSec
|
|
|
newNS = nsResult % 1000000000
|
|
|
return(nsTime(newSec, newNS))
|
|
|
|
|
|
|
|
|
def increase(self, other):
|
|
|
"""increase adds other to self, changing self (rather than creating a new object)
|
|
|
"""
|
|
|
nsResult = self.nanosecond + other.nanosecond
|
|
|
addSec = int(nsResult / 1000000000)
|
|
|
self.second = self.second + other.second + addSec
|
|
|
self.nanosecond = nsResult % 1000000000
|
|
|
self.totalNS = int(self.nanosecond) + int(self.second) * 1000000000
|
|
|
|
|
|
|
|
|
def __sub__(self, other):
|
|
|
"""__sub__ another nsTime from this one and return a new one as result
|
|
|
"""
|
|
|
nsResult = self.nanosecond - other.nanosecond
|
|
|
if nsResult < 0:
|
|
|
addSec = 1
|
|
|
nsResult += 1000000000
|
|
|
else:
|
|
|
addSec = 0
|
|
|
newSec = (self.second - other.second) - addSec
|
|
|
return(nsTime(newSec, nsResult))
|
|
|
|
|
|
|
|
|
def multiply(self, factor):
|
|
|
"""multiply this nsTime times an integer
|
|
|
"""
|
|
|
if type(factor) not in (int, int):
|
|
|
raise ValueError('Illegal type %s passed into nsTime.multiply' % (str(type(factor))))
|
|
|
newTotalNS = self.totalNS * factor
|
|
|
newSeconds = int(newTotalNS / 1000000000)
|
|
|
newNanoseconds = int(newTotalNS - (newSeconds * 1000000000))
|
|
|
return(nsTime(newSeconds, newNanoseconds))
|
|
|
|
|
|
|
|
|
def integerDivision(self, other):
|
|
|
"""integerDivision returns the total number of other nsTimes that fit in self
|
|
|
"""
|
|
|
return(int(self.totalNS / other.totalNS))
|
|
|
|
|
|
def getUnixTime(self):
|
|
|
""" getUnixTime() returns a Unix style time as a float. """
|
|
|
return(float(self.second) + float(self.nanosecond)/1.0e9)
|
|
|
|
|
|
def __mod__(self, other):
|
|
|
"""__mod__ implements self % other.
|
|
|
"""
|
|
|
if type(other) in (int, int):
|
|
|
return self.totalNS % other
|
|
|
else:
|
|
|
return self.totalNS % other.totalNS
|
|
|
|
|
|
def __eq__(self, other):
|
|
|
""" equality of two nsTime objects """
|
|
|
if not (hasattr(other, 'second') and hasattr(other, 'nanosecond')): return False
|
|
|
return self.__cmp__(other) == 0
|
|
|
|
|
|
def __cmp__(self, other):
|
|
|
"""compare two nsTime objects
|
|
|
"""
|
|
|
result = cmp(self.second, other.second)
|
|
|
if result != 0:
|
|
|
return(result)
|
|
|
|
|
|
return(cmp(self.nanosecond, other.nanosecond))
|
|
|
|
|
|
|
|
|
def __str__(self):
|
|
|
return '%d.%09d' % (self.second, self.nanosecond)
|
|
|
|
|
|
|
|
|
class psTime:
|
|
|
"""psTime is a class to handle times given as UT second (integer) and picosecond (integer)
|
|
|
|
|
|
If picosecond > 1E12, seconds will be added to second
|
|
|
"""
|
|
|
|
|
|
def __init__(self, second, picosecond):
|
|
|
self.second = int(second)
|
|
|
if self.second < 0:
|
|
|
raise ValueError('seconds must be greater than 0, not %i' % (self.second))
|
|
|
picosecond = int(picosecond)
|
|
|
if picosecond < 0:
|
|
|
raise ValueError('picoseconds must be greater 0, not %i' % (picosecond))
|
|
|
addSec = picosecond / 1000000000000
|
|
|
if addSec > 0:
|
|
|
self.second += addSec
|
|
|
self.picosecond = picosecond % 1000000000000
|
|
|
self.totalPS = int(self.picosecond) + int(self.second) * 1000000000000
|
|
|
|
|
|
|
|
|
def __add__(self, other):
|
|
|
"""__add__ another psTime to this one and return a new one as result
|
|
|
"""
|
|
|
psResult = self.picosecond + other.picosecond
|
|
|
addSec = int(psResult / 1000000000000)
|
|
|
newSec = self.second + other.second + addSec
|
|
|
newPS = psResult % 1000000000000
|
|
|
return(psTime(newSec, newPS))
|
|
|
|
|
|
|
|
|
def increase(self, other):
|
|
|
"""increase adds other to self, changing self (rather than creating a new object)
|
|
|
"""
|
|
|
psResult = self.picosecond + other.picosecond
|
|
|
addSec = int(psResult / 1000000000000)
|
|
|
self.second = self.second + other.second + addSec
|
|
|
self.picosecond = psResult % 1000000000000
|
|
|
self.totalPS = int(self.picosecond) + int(self.second) * 1000000000000
|
|
|
|
|
|
|
|
|
def __sub__(self, other):
|
|
|
"""__sub__ another psTime from this one and return a new one as result
|
|
|
"""
|
|
|
psResult = self.picosecond - other.picosecond
|
|
|
if psResult < 0:
|
|
|
addSec = 1
|
|
|
psResult += 1000000000000
|
|
|
else:
|
|
|
addSec = 0
|
|
|
newSec = (self.second - other.second) - addSec
|
|
|
return(psTime(newSec, psResult))
|
|
|
|
|
|
|
|
|
def multiply(self, factor):
|
|
|
"""multiply this psTime times an integer
|
|
|
"""
|
|
|
if type(factor) not in (int, int):
|
|
|
raise ValueError('Illegal type %s passed into psTime.multiply' % (str(type(factor))))
|
|
|
newTotalPS = self.totalPS * factor
|
|
|
newSeconds = int(newTotalPS / 1000000000000)
|
|
|
newPicoseconds = int(newTotalPS - (newSeconds * 1000000000000))
|
|
|
return(psTime(newSeconds, newPicoseconds))
|
|
|
|
|
|
|
|
|
def integerDivision(self, other):
|
|
|
"""integerDivision returns the total number of other psTimes that fit in self
|
|
|
"""
|
|
|
return(int(self.totalPS / other.totalPS))
|
|
|
|
|
|
def getUnixTime(self):
|
|
|
""" getUnixTime() returns a Unix style time as a float. """
|
|
|
return(float(self.second) + float(self.picosecond)/1.0e12)
|
|
|
|
|
|
def __mod__(self, other):
|
|
|
"""__mod__ implements self % other.
|
|
|
"""
|
|
|
if type(other) in (int, int):
|
|
|
return self.totalPS % other
|
|
|
else:
|
|
|
return self.totalPS % other.totalPS
|
|
|
|
|
|
def __eq__(self, other):
|
|
|
""" equality of two psTime objects """
|
|
|
if not (hasattr(other, 'second') and hasattr(other, 'picosecond')): return False
|
|
|
return self.__cmp__(other) == 0
|
|
|
|
|
|
def __cmp__(self, other):
|
|
|
"""compare two psTime objects
|
|
|
"""
|
|
|
result = cmp(self.second, other.second)
|
|
|
if result != 0:
|
|
|
return(result)
|
|
|
|
|
|
return(cmp(self.picosecond, other.picosecond))
|
|
|
|
|
|
|
|
|
def __str__(self):
|
|
|
return '%d.%12d' % (self.second, self.picosecond)
|
|
|
|
|
|
|
