Changes to support Python 3

wrappers/python/setup.py

@@ -69,6 +69,11 @@ def buildKeywordDictionary(major_version_num=MAJOR_VERSION_NUM,
                            build_info=BUILD_INFO):
     from distutils.core import Extension
     setupKeywords = {}
+    try:
+        from distutils.command.build_py import build_py_2to3 as build_py
+    except ImportError:
+        from distutils.command.build_py import build_py
+    setupKeywords["cmdclass"]          = {'build_py': build_py}
     setupKeywords["name"]              = "OpenMM"
     setupKeywords["version"]           = "%s.%s.%s" % (major_version_num,
                                                        minor_version_num,
@@ -158,11 +163,11 @@ def buildKeywordDictionary(major_version_num=MAJOR_VERSION_NUM,
     outputString = ''
     firstTab     = 40
     secondTab    = 60
-    for key in sorted( setupKeywords.iterkeys() ):
+    for key in sorted(iter(setupKeywords)):
          value         = setupKeywords[key]
          outputString += key.rjust(firstTab) + str( value ).rjust(secondTab) + "\n"
     
-    print "%s" % outputString
+    sys.stdout.write("%s" % outputString)
 
     return setupKeywords
     
@@ -170,8 +175,6 @@ def buildKeywordDictionary(major_version_num=MAJOR_VERSION_NUM,
 def main():
     if sys.version_info < (2, 6):
         reportError("OpenMM requires Python 2.6 or better.")
-    if sys.version_info >= (3,):
-        reportError("OpenMM has not been tested with Python 3.0 or higher.")
     if platform.system() == 'Darwin':
         macVersion = [int(x) for x in platform.mac_ver()[0].split('.')]
         if tuple(macVersion) < (10, 5):

wrappers/python/simtk/unit/basedimension.py

@@ -44,15 +44,15 @@ class BaseDimension(object):
             BaseDimension._next_unused_index += 1
         self._index = BaseDimension._index_by_name[name]
         
-    def __cmp__(self, other):
+    def __lt__(self, other):
         """
         The implicit order of BaseDimensions is the order in which they were created.
         This method is used for using BaseDimensions as hash keys, and also affects
         the order in which units appear in multi-dimensional Quantities.
         
-        Returns 0 if self == other, -1 if self < other, and 1 if self > other.
+        Returns True if self < other, False otherwise.
         """
-        return cmp(self._index, other._index)
+        return self._index < other._index
         
     def __hash__(self):
         """

wrappers/python/simtk/unit/baseunit.py

@@ -37,15 +37,15 @@ class BaseUnit(object):
         self._conversion_factor_to_by_name = {}
         self._conversion_factor_to_by_name[self.name] = 1.0
     
-    def __cmp__(self, other):
+    def __lt__(self, other):
         """
         Comparison function that sorts BaseUnits by BaseDimension
         """
         # First sort on dimension
-        c = cmp(self.dimension, other.dimension)
-        if c != 0: return c
+        if self.dimension != other.dimension:
+            return self.dimension < other.dimension
         # Second on conversion factor
-        return cmp(self.conversion_factor_to(other), 1.0)
+        return self.conversion_factor_to(other) < 1.0
 
     def iter_base_dimensions(self):
         """

wrappers/python/simtk/unit/constants.py

@@ -3,6 +3,8 @@
 Module simtk.unit.constants
 """
 
+from __future__ import division
+
 __author__ = "Christopher M. Bruns"
 __version__ = "0.5"
 

wrappers/python/simtk/unit/doctests.py

@@ -36,9 +36,9 @@ False
 >>> c = 1.0*calories
 >>> c
 Quantity(value=1.0, unit=calorie)
->>> print calorie.conversion_factor_to(joule)
+>>> print(calorie.conversion_factor_to(joule))
 4.184
->>> print joule.conversion_factor_to(calorie)
+>>> print(joule.conversion_factor_to(calorie))
 0.239005736138
 >>> c.in_units_of(joules)
 Quantity(value=4.1840000000000002, unit=joule)
@@ -49,9 +49,9 @@ Quantity(value=1.0, unit=joule)
 Quantity(value=0.23900573613766729, unit=calorie)
 >>> j/joules
 1.0
->>> print j/calories
+>>> print(j/calories)
 0.239005736138
->>> print c/joules
+>>> print(c/joules)
 4.184
 >>> c/calories
 1.0
@@ -75,33 +75,33 @@ False
 
 Examples
 
->>> print meter / second
+>>> print(meter / second)
 meter/second
->>> print meter / meter
+>>> print(meter / meter)
 dimensionless
 
 Heterogeneous units are not reduced unless they are in a quantity.
->>> print meter / centimeter
+>>> print(meter / centimeter)
 meter/centimeter
 
 Examples
 
 >>> meters_per_second = Unit({meter_base_unit: 1.0, second_base_unit: -1.0})
->>> print meters_per_second
+>>> print(meters_per_second)
 meter/second
 
 >>> us = UnitSystem([ScaledUnit(1.0, coulomb/second, "ampere", "A"), second_base_unit])
->>> print us.express_unit(second)
+>>> print(us.express_unit(second))
 second
->>> print us.express_unit(coulomb/second)
+>>> print(us.express_unit(coulomb/second))
 ampere
->>> print us.express_unit(coulomb)
+>>> print(us.express_unit(coulomb))
 second*ampere
->>> print us.express_unit(meter/second)
+>>> print(us.express_unit(meter/second))
 meter/second
 
 >>> us = UnitSystem([ScaledUnit(1.0, coulomb/second, "ampere", "A"), second_base_unit])
->>> print us
+>>> print(us)
 UnitSystem([ampere, second])
 
 Examples
@@ -111,7 +111,7 @@ False
 >>> (meter/meter).is_dimensionless()
 True
 
->>> print (meter*meter).sqrt()
+>>> print((meter*meter).sqrt())
 meter
 >>> meter.sqrt()
 Traceback (most recent call last):
@@ -121,13 +121,13 @@ ArithmeticError: Exponents in Unit.sqrt() must be even.
 Traceback (most recent call last):
   ...
 ArithmeticError: Exponents in Unit.sqrt() must be even.
->>> print (meter*meter/second/second).sqrt()
+>>> print((meter*meter/second/second).sqrt())
 meter/second
 
 Mixture of BaseUnits and ScaledUnits should cause no trouble:
->>> print sqrt(kilogram*joule)
+>>> print(sqrt(kilogram*joule))
 kilogram*meter/second
->>> print sqrt(kilogram*calorie)
+>>> print(sqrt(kilogram*calorie))
 kilogram*meter/second
 
 Examples
@@ -146,20 +146,20 @@ Examples
 
 Examples
 
->>> print angstrom.in_unit_system(si_unit_system)
+>>> print(angstrom.in_unit_system(si_unit_system))
 meter
->>> print angstrom.in_unit_system(cgs_unit_system)
+>>> print(angstrom.in_unit_system(cgs_unit_system))
 centimeter
->>> print angstrom.in_unit_system(md_unit_system)
+>>> print(angstrom.in_unit_system(md_unit_system))
 nanometer
 >>> u = meter/second**2
->>> print u
+>>> print(u)
 meter/(second**2)
->>> print u.in_unit_system(si_unit_system)
+>>> print(u.in_unit_system(si_unit_system))
 meter/(second**2)
->>> print u.in_unit_system(cgs_unit_system)
+>>> print(u.in_unit_system(cgs_unit_system))
 centimeter/(second**2)
->>> print u.in_unit_system(md_unit_system)
+>>> print(u.in_unit_system(md_unit_system))
 nanometer/(picosecond**2)
 
 Examples
@@ -180,99 +180,99 @@ Examples
 >>> meter.conversion_factor_to(centimeter)
 100.0
 
->>> print (md_kilocalorie/mole/angstrom).conversion_factor_to(md_kilojoule/mole/nanometer)
+>>> print((md_kilocalorie/mole/angstrom).conversion_factor_to(md_kilojoule/mole/nanometer))
 41.84
 
 Examples
 
->>> print meter
+>>> print(meter)
 meter
 
->>> print meter * second * second * kilogram
+>>> print(meter * second * second * kilogram)
 kilogram*meter*second**2
->>> print meter / second / second / kilogram
+>>> print(meter / second / second / kilogram)
 meter/(kilogram*second**2)
 
 Examples
 
->>> print meter**3
+>>> print(meter**3)
 meter**3
->>> print meter**3
+>>> print(meter**3)
 meter**3
 
 >>> meter.get_conversion_factor_to_base_units()
 1.0
 
 Simple ScaledUnit in calorie
->>> print calorie.get_conversion_factor_to_base_units()
+>>> print(calorie.get_conversion_factor_to_base_units())
 4.184
 
 Compound ScaledUnit in md_kilocalorie
->>> print md_kilocalorie.get_conversion_factor_to_base_units()
+>>> print(md_kilocalorie.get_conversion_factor_to_base_units())
 4.184
 
 calorie in a more complex unit
->>> print (md_kilocalorie/mole/angstrom).get_conversion_factor_to_base_units()
+>>> print((md_kilocalorie/mole/angstrom).get_conversion_factor_to_base_units())
 4.184
 
 Examples
 
 Create simple Quantities with either the multiply operator or the Quantity constructor.
->>> print 5 * centimeters
+>>> print(5 * centimeters)
 5 cm
->>> print Quantity(value=5, unit=centimeter)
+>>> print(Quantity(value=5, unit=centimeter))
 5 cm
->>> print Quantity(5, centimeter)
+>>> print(Quantity(5, centimeter))
 5 cm
 
 Extract the underlying value using either division or the value_in_unit() method.
 >>> i = 5 * centimeters
->>> print i / millimeters
+>>> print(i / millimeters)
 50.0
->>> print i.value_in_unit(millimeters)
+>>> print(i.value_in_unit(millimeters))
 50.0
 
 Collections of numbers can also be used as values.
 >>> s = [1,2,3] * centimeters
->>> print s
+>>> print(s)
 [1, 2, 3] cm
->>> print s / millimeters
+>>> print(s / millimeters)
 [10.0, 20.0, 30.0]
 >>> s2 = [[1,2,3],[4,5,6]] * centimeters
->>> print s2
+>>> print(s2)
 [[1, 2, 3], [4, 5, 6]] cm
->>> print s2 / millimeters
+>>> print(s2 / millimeters)
 [[10.0, 20.0, 30.0], [40.0, 50.0, 60.0]]
 >>> s3 = [(1,2,3),(4,5,6)] * centimeters
->>> print s3
+>>> print(s3)
 [(1, 2, 3), (4, 5, 6)] cm
->>> print s3 / millimeters
+>>> print(s3 / millimeters)
 [(10.0, 20.0, 30.0), (40.0, 50.0, 60.0)]
 >>> s4 = ((1,2,3),(4,5,6)) * centimeters
->>> print s4
+>>> print(s4)
 ((1, 2, 3), (4, 5, 6)) cm
->>> print s4 / millimeters
+>>> print(s4 / millimeters)
 [(10.0, 20.0, 30.0), (40.0, 50.0, 60.0)]
 >>> t = (1,2,3) * centimeters
->>> print t
+>>> print(t)
 (1, 2, 3) cm
->>> print t / millimeters
+>>> print(t / millimeters)
 [10.0, 20.0, 30.0]
 
 Numpy examples are commented out because not all systems have numpy installed
 # >>> import numpy
 # >>> 
 # >>> a = Quantity(numpy.array([1,2,3]), centimeters)
-# >>> print a
+# >>> print(a)
 # [1 2 3] cm
-# >>> print a / millimeters
+# >>> print(a / millimeters)
 # [ 10.  20.  30.]
 # >>> 
 # >>> a2 = Quantity(numpy.array([[1,2,3],[4,5,6]]), centimeters)
-# >>> print a2
+# >>> print(a2)
 # [[1 2 3]
 #  [4 5 6]] cm
-# >>> print a2 / millimeters
+# >>> print(a2 / millimeters)
 # [[ 10.  20.  30.]
 #  [ 40.  50.  60.]]     
 
@@ -280,13 +280,13 @@ Addition, subtraction, multiplication, division, and powers of Quantities
 exhibit correct dimensional analysis and unit conversion.
 >>> x = 1.3 * meters
 >>> y = 75.2 * centimeters
->>> print x + y
+>>> print(x + y)
 2.052 m
->>> print x - y
+>>> print(x - y)
 0.548 m
->>> print x/y
+>>> print(x/y)
 1.72872340426
->>> print x*y
+>>> print(x*y)
 0.9776 m**2
 
 The following examples are derived from the C++ Boost.Units examples at
@@ -294,61 +294,61 @@ http://www.boost.org/doc/libs/1_37_0/doc/html/boost_units/Examples.html
 >>>
 >>> l = 2.0 * meters
 >>> 
->>> print l + 2.0 * nanometers
+>>> print(l + 2.0 * nanometers)
 2.000000002 m
->>> print 2.0 * nanometers + l
+>>> print(2.0 * nanometers + l)
 2000000002.0 nm
 >>> 
->>> print l
+>>> print(l)
 2.0 m
->>> print l+l
+>>> print(l+l)
 4.0 m
->>> print l-l
+>>> print(l-l)
 0.0 m
->>> print l*l
+>>> print(l*l)
 4.0 m**2
->>> print l/l
+>>> print(l/l)
 1.0
->>> print l * meter
+>>> print(l * meter)
 2.0 m**2
->>> print kilograms * (l/seconds) * (l/seconds)
+>>> print(kilograms * (l/seconds) * (l/seconds))
 4.0 kg m**2/(s**2)
->>> print kilograms * (l/seconds)**2
+>>> print(kilograms * (l/seconds)**2)
 4.0 kg m**2/(s**2)
->>> print l ** 3
+>>> print(l ** 3)
 8.0 m**3
->>> print l ** (3.0/2.0)
+>>> print(l ** (3.0/2.0))
 2.82842712475 m**1.5
->>> print l ** 0.5
+>>> print(l ** 0.5)
 1.41421356237 m**0.5
->>> print l ** (2.0/3.0)
+>>> print(l ** (2.0/3.0))
 1.58740105197 m**0.666667
 >>> # complex example
 >>> l = (3.0 + 4.0j) * meters
->>> print l
+>>> print(l)
 (3+4j) m
->>> print l+l
+>>> print(l+l)
 (6+8j) m
->>> print l-l
+>>> print(l-l)
 0j m
->>> print l*l
+>>> print(l*l)
 (-7+24j) m**2
 >>> # Numerical error yields tiny imaginary component of l/l on linux CentOS5
 >>> err = abs(l/l - 1)
 >>> assert err < 1e-8
->>> print l * meter
+>>> print(l * meter)
 (3+4j) m**2
->>> print kilograms * (l/seconds) * (l/seconds)
+>>> print(kilograms * (l/seconds) * (l/seconds))
 (-7+24j) kg m**2/(s**2)
->>> print kilograms * (l/seconds)**2
+>>> print(kilograms * (l/seconds)**2)
 (-7+24j) kg m**2/(s**2)
->>> print l ** 3
+>>> print(l ** 3)
 (-117+44j) m**3
->>> print l ** (3.0/2.0)
+>>> print(l ** (3.0/2.0))
 (2+11j) m**1.5
->>> print l ** 0.5
+>>> print(l ** 0.5)
 (2+1j) m**0.5
->>> print l ** (2.0/3.0)
+>>> print(l ** (2.0/3.0))
 (2.38285471252+1.69466313833j) m**0.666667
 >>> # kitchen sink example
 ... s1 = 2.0
@@ -358,57 +358,57 @@ http://www.boost.org/doc/libs/1_37_0/doc/html/boost_units/Examples.html
 >>> u2 = u1 * meter
 >>> q1 = 1.0*u1
 >>> q2 = 2.0*u2
->>> print s1
+>>> print(s1)
 2.0
->>> print x1
+>>> print(x1)
 2
->>> print x2
+>>> print(x2)
 1.33333333333
->>> print u1
+>>> print(u1)
 kilogram*meter/(second**2)
->>> print u2
+>>> print(u2)
 kilogram*meter**2/(second**2)
->>> print q1
+>>> print(q1)
 1.0 kg m/(s**2)
->>> print q2
+>>> print(q2)
 2.0 kg m**2/(s**2)
->>> print u1*s1
+>>> print(u1*s1)
 2.0 kg m/(s**2)
->>> print s1*u1
+>>> print(s1*u1)
 2.0 kg m/(s**2)
->>> print u1/s1
+>>> print(u1/s1)
 0.5 kg m/(s**2)
->>> print s1/u1
+>>> print(s1/u1)
 2.0 s**2/(kg m)
->>> print u1*u1
+>>> print(u1*u1)
 kilogram**2*meter**2/(second**4)
->>> print u1/u1
+>>> print(u1/u1)
 dimensionless
->>> print u1*u2
+>>> print(u1*u2)
 kilogram**2*meter**3/(second**4)
->>> print u1/u2
+>>> print(u1/u2)
 /meter
->>> print u1**x1
+>>> print(u1**x1)
 kilogram**2*meter**2/(second**4)
->>> print u1**(1.0/x1)
+>>> print(u1**(1.0/x1))
 kilogram**0.5*meter**0.5/second
->>> print u1**x2
+>>> print(u1**x2)
 kilogram**1.33333*meter**1.33333/(second**2.66667)
->>> print u1**(1.0/x2)
+>>> print(u1**(1.0/x2))
 kilogram**0.75*meter**0.75/(second**1.5)
 >>> l1 = 1.0*meters
 >>> l2 = 2.0*meters
->>> print l1 == l2
+>>> print(l1 == l2)
 False
->>> print l1 != l2
+>>> print(l1 != l2)
 True
->>> print l1 <= l2
+>>> print(l1 <= l2)
 True
->>> print l1 < l2
+>>> print(l1 < l2)
 True
->>> print l1 >= l2
+>>> print(l1 >= l2)
 False
->>> print l1 > l2
+>>> print(l1 > l2)
 False
 >>> 
 >>> def work(f, dx):
@@ -418,15 +418,15 @@ False
 >>> dx = 1.0 * meter
 >>> E = work(F, dx)
 >>> 
->>> print "F = ", F
+>>> print("F = ", F)
 F =  1.0 kg m/(s**2)
->>> print "dx = ", dx
+>>> print("dx = ", dx)
 dx =  1.0 m
 >>> 
 >>> def idealGasLaw(P, V, T):
 ...     R = MOLAR_GAS_CONSTANT_R
-...     print "P * V = ", P * V
-...     print "R * T = ", R * T
+...     print("P * V = ", P * V)
+...     print("R * T = ", R * T)
 ...     return (P * V / (R * T)).in_units_of(mole)
 ... 
 >>> T = (273.0 + 37.0) * kelvin
@@ -438,82 +438,82 @@ P * V =  5.3053601125e-14 m**3 Pa
 R * T =  2577.48646608 J/mol
 >>> R = MOLAR_GAS_CONSTANT_R
 >>> 
->>> print "r = ", r
+>>> print("r = ", r)
 r =  5e-07 m
->>> print "P = ", P
+>>> print("P = ", P)
 P =  101325.0 Pa
->>> print "V = ", V
+>>> print("V = ", V)
 V =  5.23598333333e-19 m**3
->>> print "T = ", T
+>>> print("T = ", T)
 T =  310.0 K
->>> print "n = ", n
+>>> print("n = ", n)
 n =  2.05834644811e-17 mol
->>> print "R = ", R
+>>> print("R = ", R)
 R =  8.31447247122 J/(K mol)
->>> print "E = ", E
+>>> print("E = ", E)
 E =  1.0 kg m**2/(s**2)
->>> print "is_quantity(V) = ", is_quantity(V)
+>>> print("is_quantity(V) = ", is_quantity(V))
 is_quantity(V) =  True
->>> print (1.0*radians) / degrees
+>>> print((1.0*radians) / degrees)
 57.2957795131
->>> print (1.0*radians).in_units_of(degrees)
+>>> print((1.0*radians).in_units_of(degrees))
 57.2957795131 deg
->>> print (1.0*angstroms).in_units_of(nanometers)
+>>> print((1.0*angstroms).in_units_of(nanometers))
 0.1 nm
 >>> 
->>> print (90*degrees)/radians
+>>> print((90*degrees)/radians)
 1.57079632679
->>> print sin(90*degrees)
+>>> print(sin(90*degrees))
 1.0
 >>> x = 90 * degrees
 >>> x += 0.3 * radians
->>> print x
+>>> print(x)
 107.188733854 deg
->>> print 1 * nanometers > 1 * angstroms
+>>> print(1 * nanometers > 1 * angstroms)
 True
->>> print 1 * nanometers > 1 * degrees
+>>> print(1 * nanometers > 1 * degrees)
 Traceback (most recent call last):
    ...
 TypeError: Unit "degree" is not compatible with Unit "nanometer".
 >>> 
 >>> x = 1.5 * nanometers
->>> print x / meters
+>>> print(x / meters)
 1.5e-09
 >>> x = 1.5 * angstroms
->>> print x / meters
+>>> print(x / meters)
 1.5e-10
->>> print x / nanometers
+>>> print(x / nanometers)
 0.15
 
 Examples
 
->>> print is_quantity(meters)
+>>> print(is_quantity(meters))
 False
->>> print is_quantity(2.3*meters)
+>>> print(is_quantity(2.3*meters))
 True
->>> print is_quantity(2.3)
+>>> print(is_quantity(2.3))
 False
 
 Examples
 
 >>> x = 100.0 * millimeter
->>> print x.value_in_unit_system(si_unit_system)
+>>> print(x.value_in_unit_system(si_unit_system))
 0.1
->>> print x.value_in_unit_system(cgs_unit_system)
+>>> print(x.value_in_unit_system(cgs_unit_system))
 10.0
->>> print x.value_in_unit_system(md_unit_system)
+>>> print(x.value_in_unit_system(md_unit_system))
 100000000.0
 >>> 
 >>> y = 20 * millimeters / millisecond**2
->>> print y.value_in_unit_system(si_unit_system)
+>>> print(y.value_in_unit_system(si_unit_system))
 20000.0
->>> print y.value_in_unit_system(cgs_unit_system)
+>>> print(y.value_in_unit_system(cgs_unit_system))
 2000000.0
->>> print y.value_in_unit_system(md_unit_system)
+>>> print(y.value_in_unit_system(md_unit_system))
 2e-11
 >>> eps = Quantity(1.0, md_kilocalorie/mole)
 >>> epsQ = eps.value_in_unit_system(md_unit_system)
->>> print epsQ
+>>> print(epsQ)
 4.184
 
 Dimensionless quantities return their unmodified values.
@@ -523,32 +523,32 @@ Dimensionless quantities return their unmodified values.
 Examples
 
 >>> x = 2.3*meters
->>> print x.value_in_unit(centimeters)
+>>> print(x.value_in_unit(centimeters))
 230.0
 
 Examples
 
->>> print bool(2.3*meters)
+>>> print(bool(2.3*meters))
 True
->>> print bool(0*meters)
+>>> print(bool(0*meters))
 False
 
 
 Examples
 
->>> print -(2.3*meters)
+>>> print(-(2.3*meters))
 -2.3 m
->>> print -(-2.3*meters)
+>>> print(-(-2.3*meters))
 2.3 m
 
 Examples
 
->>> print +(2.3*meters)
+>>> print(+(2.3*meters))
 2.3 m
 
 Examples
 
->>> print abs(-2.3*meters)
+>>> print(abs(-2.3*meters))
 2.3 m
 
 >>> (9.0*meter*meter).sqrt()
@@ -572,22 +572,22 @@ Quantity(value=2.0454828280872954, unit=kilogram*meter/second)
 
 Examples
 
->>> print (2.3*meters)**2
+>>> print((2.3*meters)**2)
 5.29 m**2
 
 Examples
 
 >>> x = 4.2 * centimeters
->>> print 8.4 / x
+>>> print(8.4 / x)
 2.0 /cm
 
         
         Examples
         
         >>> x = 4.3 * meters
-        >>> print x/centimeters
+        >>> print(x/centimeters)
         430.0
-        >>> print x/seconds
+        >>> print(x/seconds)
         4.3 m/s
         >>> x = [1,2,3]*centimeter
         >>> x/millimeter
@@ -597,14 +597,14 @@ Examples
         Examples
         
         >>> x = 1.2*meters
-        >>> print 5*x
+        >>> print(5*x)
         6.0 m
         
         Examples
         
         >>> x = 1.2*meters
         >>> y = 72*centimeters
-        >>> print x*y
+        >>> print(x*y)
         0.864 m**2
         >>> x = [1,2,3]*centimeter
         >>> x
@@ -613,7 +613,7 @@ Examples
         Quantity(value=[100.0, 200.0, 300.0], unit=centimeter**2)
 
         >>> u = nanometer**2/angstrom**2
-        >>> print u
+        >>> print(u)
         nanometer**2/(angstrom**2)
         >>> q = Quantity(2.0, u)
         >>> q
@@ -632,23 +632,23 @@ Examples
         
         Examples
         
-        >>> print 1.2 * meters - 72 * centimeters
+        >>> print(1.2 * meters - 72 * centimeters)
         0.48 m
         
         Examples
         
-        >>> print 1.2 * meters + 72 * centimeters
+        >>> print(1.2 * meters + 72 * centimeters)
         1.92 m
         
         Examples
         
-        >>> print repr(1.2*meter)
+        >>> print(repr(1.2*meter))
         Quantity(value=1.2, unit=meter)
 
         
         Examples
         
-        >>> print 5.0 * nanometers
+        >>> print(5.0 * nanometers)
         5.0 nm
         
         Examples
@@ -689,13 +689,13 @@ Examples
         
         >>> x = 2.3*meters
         >>> y = x.in_units_of(centimeters)
-        >>> print y
+        >>> print(y)
         230.0 cm
         
         >>> x = 2.3*meters
-        >>> print x.in_units_of(centimeters)
+        >>> print(x.in_units_of(centimeters))
         230.0 cm
-        >>> print x.in_units_of(seconds)
+        >>> print(x.in_units_of(seconds))
         Traceback (most recent call last):
            ...
         TypeError: Unit "meter" is not compatible with Unit "second".
@@ -703,34 +703,34 @@ Examples
         Examples
         
         >>> x = 100.0 * millimeter
-        >>> print x
+        >>> print(x)
         100.0 mm
-        >>> print x.in_unit_system(si_unit_system)
+        >>> print(x.in_unit_system(si_unit_system))
         0.1 m
-        >>> print x.in_unit_system(cgs_unit_system)
+        >>> print(x.in_unit_system(cgs_unit_system))
         10.0 cm
-        >>> print x.in_unit_system(md_unit_system)
+        >>> print(x.in_unit_system(md_unit_system))
         100000000.0 nm
         >>> y = 20 * millimeters / millisecond**2
-        >>> print y
+        >>> print(y)
         20 mm/(ms**2)
-        >>> print y.in_unit_system(si_unit_system)
+        >>> print(y.in_unit_system(si_unit_system))
         20000.0 m/(s**2)
-        >>> print y.in_unit_system(cgs_unit_system)
+        >>> print(y.in_unit_system(cgs_unit_system))
         2000000.0 cm/(s**2)
-        >>> print y.in_unit_system(md_unit_system)
+        >>> print(y.in_unit_system(md_unit_system))
         2e-11 nm/(ps**2)
 
         Sometimes mixed internal units have caused trouble:
         >>> q = 1.0 * md_kilocalorie/mole/angstrom
-        >>> print q.in_units_of(md_kilojoule/mole/nanometer)
+        >>> print(q.in_units_of(md_kilojoule/mole/nanometer))
         41.84 kJ/(nm mol)
         
         Examples
         
         >>> class Foo:
         ...     def bar(self):
-        ...         print "bar"
+        ...         print("bar")
         ... 
         >>> x = Foo()
         >>> x.bar()
@@ -741,24 +741,24 @@ Examples
     
     Examples
     
-    >>> print meters * centimeters
+    >>> print(meters * centimeters)
     centimeter*meter
-    >>> print meters * meters
+    >>> print(meters * meters)
     meter**2
-    >>> print meter * meter 
+    >>> print(meter * meter )
     meter**2
 
     
     Examples
     
-    >>> print meter / 2
+    >>> print(meter / 2)
     0.5 m
      
     Examples
      
     >>> define_prefixed_units(kelvin_base_unit, sys.modules["__main__"])
     >>> from __main__ import millikelvin
-    >>> print 5.0 * millikelvin
+    >>> print(5.0 * millikelvin)
     5.0 mK
     
         
@@ -821,17 +821,17 @@ Examples
 >>> V = 2.4 * nanometer**3
 >>> beta = 4.e-4 * mole/joule
 >>> x1 = beta*p1*V
->>> # print x1
+>>> # print(x1)
 ... y1 = x1 * AVOGADRO_CONSTANT_NA
->>> print y1
+>>> print(y1)
 0.0585785776197
 
 # Wrong answer is 5.85785776197e+25
 
 >>> x2 = beta*p2*V
->>> # print x2
+>>> # print(x2)
 ... y2 = x2 * AVOGADRO_CONSTANT_NA
->>> print y2
+>>> print(y2)
 0.0585785776197
 >>> assert( abs(y1 - y2) < 0.01)
 
@@ -863,6 +863,8 @@ Examples
 
 """
 
+from __future__ import print_function
+
 __author__ = "Christopher M. Bruns"
 __version__ = "0.5"
 

wrappers/python/simtk/unit/mymatrix.py

@@ -8,7 +8,7 @@ def eye(size):
     """
     Returns identity matrix.
     
-    >>> print eye(3)
+    >>> print(eye(3))
     [[1, 0, 0]
      [0, 1, 0]
      [0, 0, 1]]
@@ -28,7 +28,7 @@ def zeros(m, n=None):
     """
     Returns matrix of zeroes
     
-    >>> print zeros(3)
+    >>> print(zeros(3))
     [[0, 0, 0]
      [0, 0, 0]
      [0, 0, 0]]
@@ -94,13 +94,13 @@ class MyMatrix(MyVector):
     Pure python linear algebra matrix for internal matrix inversion in UnitSystem.
     
     >>> m = MyMatrix([[1,0,],[0,1,]])
-    >>> print m
+    >>> print(m)
     [[1, 0]
      [0, 1]]
-    >>> print ~m
+    >>> print(~m)
     [[1.0, 0.0]
      [0.0, 1.0]]
-    >>> print eye(5)
+    >>> print(eye(5))
     [[1, 0, 0, 0, 0]
      [0, 1, 0, 0, 0]
      [0, 0, 1, 0, 0]
@@ -111,18 +111,18 @@ class MyMatrix(MyVector):
     1
     >>> m[1:4]
     MyMatrixTranspose([[0, 0, 0],[1, 0, 0],[0, 1, 0],[0, 0, 1],[0, 0, 0]])
-    >>> print m[1:4]
+    >>> print(m[1:4])
     [[0, 0, 0]
      [1, 0, 0]
      [0, 1, 0]
      [0, 0, 1]
      [0, 0, 0]]
-    >>> print m[1:4][0:2]
+    >>> print(m[1:4][0:2])
     [[0, 1]
      [0, 0]
      [0, 0]]
     >>> m[1:4][0:2] = [[9,8],[7,6],[5,4]]
-    >>> print m
+    >>> print(m)
     [[1, 0, 0, 0, 0]
      [9, 8, 0, 0, 0]
      [7, 6, 1, 0, 0]
@@ -182,13 +182,13 @@ class MyMatrix(MyVector):
         
         >>> a = MyMatrix([[1,2],[3,4]])
         >>> b = MyMatrix([[5,6],[7,8]])
-        >>> print a
+        >>> print(a)
         [[1, 2]
          [3, 4]]
-        >>> print b
+        >>> print(b)
         [[5, 6]
          [7, 8]]
-        >>> print a*b
+        >>> print(a*b)
         [[19, 22]
          [43, 50]]
         
@@ -209,7 +209,7 @@ class MyMatrix(MyVector):
         """
         Matrix addition.
         
-        >>> print MyMatrix([[1, 2],[3, 4]]) + MyMatrix([[5, 6],[7, 8]])
+        >>> print(MyMatrix([[1, 2],[3, 4]]) + MyMatrix([[5, 6],[7, 8]]))
         [[6, 8]
          [10, 12]]
         """
@@ -227,7 +227,7 @@ class MyMatrix(MyVector):
         """
         Matrix subtraction.
         
-        >>> print MyMatrix([[1, 2],[3, 4]]) - MyMatrix([[5, 6],[7, 8]])
+        >>> print(MyMatrix([[1, 2],[3, 4]]) - MyMatrix([[5, 6],[7, 8]]))
         [[-4, -4]
          [-4, -4]]
         """
@@ -256,32 +256,32 @@ class MyMatrix(MyVector):
     def __invert__(self):
         """
         >>> m = MyMatrix([[1,1],[0,1]])
-        >>> print m
+        >>> print(m)
         [[1, 1]
          [0, 1]]
-        >>> print ~m
+        >>> print(~m)
         [[1.0, -1.0]
          [0.0, 1.0]]
-        >>> print m*~m
+        >>> print(m*~m)
         [[1.0, 0.0]
          [0.0, 1.0]]
-        >>> print ~m*m
+        >>> print(~m*m)
         [[1.0, 0.0]
          [0.0, 1.0]]
         >>> m = MyMatrix([[1,0,0],[0,0,1],[0,-1,0]])
-        >>> print m
+        >>> print(m)
         [[1, 0, 0]
          [0, 0, 1]
          [0, -1, 0]]
-        >>> print ~m
+        >>> print(~m)
         [[1.0, 0.0, 0.0]
          [0.0, 0.0, -1.0]
          [0.0, 1.0, 0.0]]
-        >>> print m*~m
+        >>> print(m*~m)
         [[1.0, 0.0, 0.0]
          [0.0, 1.0, 0.0]
          [0.0, 0.0, 1.0]]
-        >>> print ~m*m
+        >>> print(~m*m)
         [[1.0, 0.0, 0.0]
          [0.0, 1.0, 0.0]
          [0.0, 0.0, 1.0]]

wrappers/python/simtk/unit/quantity.py

@@ -39,6 +39,8 @@ Two possible enhancements that have not been implemented are
   2) Incorporate offsets for celsius <-> kelvin conversion
 """
 
+from __future__ import division
+
 __author__ = "Christopher M. Bruns"
 __version__ = "0.5"
 
@@ -232,25 +234,23 @@ class Quantity(object):
         """
         if not is_quantity(other):
             return False
-        else:
-            return NotImplemented # punt to cmp
+        if not self.unit.is_compatible(other.unit):
+            return False
+        return self.value_in_unit(other.unit) == other._value
             
     def __ne__(self, other):
         """
         """
-        if not is_quantity(other):
-            return True
-        else:
-            return NotImplemented # punt to cmp
+        return not self.__eq__(other)
 
-    def __cmp__(self, other):
+    def __lt__(self, other):
         """Compares two quantities.
         
         Raises TypeError if the Quantities are of different dimension (e.g. length vs. mass)
         
-        Returns -1 if self < other, 0 if self == other, and 1 if self > other.
+        Returns True if self < other, False otherwise.
         """
-        return cmp(self._value, (other.value_in_unit(self.unit)))       
+        return self._value < other.value_in_unit(self.unit)
 
     def __ge__(self, other):
         return self._value >= (other.value_in_unit(self.unit))     
@@ -363,7 +363,7 @@ class Quantity(object):
             return self._change_units_with_factor(self.unit, other, post_multiply=True)
             # return Quantity(other * self._value, self.unit)
         
-    def __div__(self, other):
+    def __truediv__(self, other):
         """Divide a Quantity by another object
 
         Returns a new Quantity, unless the resulting unit type is dimensionless,
@@ -383,16 +383,16 @@ class Quantity(object):
             return self * pow(other, -1.0)
             # return Quantity(self._value / other, self.unit)
 
-    def __rdiv__(self, other):
+    def __rtruediv__(self, other):
         """Divide a scalar by a quantity.
         
         Returns a new Quantity.  The resulting units are the inverse of the self argument units.
         """
         if is_unit(other):
             # print "R unit / quantity"
-            raise NotImplementedError('programmer is surprised __rdiv__ was called instead of __div__')
+            raise NotImplementedError('programmer is surprised __rtruediv__ was called instead of __truediv__')
         elif is_quantity(other):
-            raise NotImplementedError('programmer is surprised __rdiv__ was called instead of __div__')
+            raise NotImplementedError('programmer is surprised __rtruediv__ was called instead of __truediv__')
         else:
             # print "R scalar / quantity"
             return other * pow(self, -1.0)

wrappers/python/simtk/unit/unit.py

@@ -5,6 +5,8 @@ Module simtk.unit
 Contains classes Unit and ScaledUnit.
 """
 
+from __future__ import division
+
 __author__ = "Christopher M. Bruns"
 __version__ = "0.5"
 
@@ -149,17 +151,16 @@ class Unit(object):
     def __ne__(self, other):
         return not self.__eq__(other)
 
-    def __cmp__(self, other):
+    def __lt__(self, other):
         """Compare two Units.
         
         Raises a TypeError if the units have different dimensions.
         
-        Returns 0 if the Units are equal, -1 if the first Unit is smaller, 
-        and returns 1 if the first Unit is larger.
+        Returns True if self < other, False otherwise.
         """
         if not self.is_compatible(other):
             raise TypeError('Unit "%s" is not compatible with Unit "%s".', (self, other))
-        return cmp(self.conversion_factor_to(other), 1.0)
+        return self.conversion_factor_to(other) < 1.0
 
     def __hash__(self):
         """
@@ -175,7 +176,7 @@ class Unit(object):
     # def __mul__(self, other):
     # See unit_operators.py for Unit.__mul__ operator
     
-    def __div__(self, other):
+    def __truediv__(self, other):
         """Divide a Unit by another object.
         
         Returns a composite Unit if other is another Unit.
@@ -186,8 +187,8 @@ class Unit(object):
         """
         return self * pow(other, -1)
 
-    # def __rdiv__(self, other):
-    # Because rdiv returns a Quantity, look in quantity.py for definition of Unit.__rdiv__
+    # def __rtruediv__(self, other):
+    # Because rtruediv returns a Quantity, look in quantity.py for definition of Unit.__rtruediv__
 
     _pow_cache = {}
 
@@ -522,6 +523,11 @@ class ScaledUnit(object):
         else:
             other_u = Unit({other: 1.0})
         return self.factor * Unit(u).conversion_factor_to(other_u)
+
+    def __lt__(self, other):
+        """Compare two ScaledUnits.
+        """
+        return hash(self) < hash(other)
         
     def __str__(self):
         """Returns a string with the name of this ScaledUnit
@@ -569,7 +575,7 @@ class UnitSystem(object):
                 to_base_units[m][n] = power
         try:
             self.from_base_units = ~to_base_units
-        except ArithmeticError, e:
+        except ArithmeticError as e:
         # for compatibility between python 2.5 and python 3.0,
         # try replacing line above with the following two lines:
         # except ArithmeticError:

wrappers/python/simtk/unit/unit_definitions.py

@@ -4,6 +4,8 @@ Module simtk.unit.unit_definitions
 
 """
 
+from __future__ import division
+
 __author__ = "Christopher M. Bruns"
 __version__ = "0.6"
 

wrappers/python/simtk/unit/unit_math.py

@@ -5,6 +5,8 @@ Module simtk.unit.math
 Arithmetic methods on Quantities and Units
 """
 
+from __future__ import division
+
 __author__ = "Christopher M. Bruns"
 __version__ = "0.5"
 
@@ -69,7 +71,7 @@ def acos(x):
     """
     >>> acos(1.0)
     Quantity(value=0.0, unit=radian)
-    >>> print acos(1.0)
+    >>> print(acos(1.0))
     0.0 rad
     """
     return math.acos(x) * radians
@@ -100,7 +102,7 @@ def sqrt(val):
     """
     >>> sqrt(9.0)
     3.0
-    >>> print sqrt(meter*meter)
+    >>> print(sqrt(meter*meter))
     meter
     >>> sqrt(9.0*meter*meter)
     Quantity(value=3.0, unit=meter)

wrappers/python/simtk/unit/unit_operators.py

@@ -36,14 +36,14 @@ def _unit_class_rdiv(self, other):
     of the inverse of self.
     """
     if is_unit(other):
-        raise NotImplementedError('programmer is surprised __rdiv__ was called instead of __div__')
+        raise NotImplementedError('programmer is surprised __rtruediv__ was called instead of __truediv__')
     else:
         # print "R scalar / unit"
         unit = pow(self, -1.0)
         value = other
         return Quantity(value, unit).reduce_unit(self)
 
-Unit.__rdiv__ = _unit_class_rdiv
+Unit.__rtruediv__ = _unit_class_rdiv
 
 
 def _unit_class_mul(self, other):

wrappers/python/src/swig_doxygen/swigInputBuilder.py

@@ -188,7 +188,7 @@ class SwigInputBuilder:
 
     def writeGlobalConstants(self):
         self.fOut.write("/* Global Constants */\n\n")
-        node = (x for x in findNodes(self.doc.getroot(), "compounddef", kind="namespace") if x.findtext("compoundname") == "OpenMM").next()
+        node = next((x for x in findNodes(self.doc.getroot(), "compounddef", kind="namespace") if x.findtext("compoundname") == "OpenMM"))
         for section in findNodes(node, "sectiondef", kind="var"):
             for memberNode in findNodes(section, "memberdef", kind="variable", mutable="no", prot="public", static="yes"):
                 vDef = stripOpenmmPrefix(getText("definition", memberNode))

wrappers/python/src/swig_doxygen/swig_lib/python/pythoncode.i

@@ -250,9 +250,9 @@ def stripUnits(args):
     newArgList=[]
     for arg in args:
         if unit.is_quantity(arg):
-	    # JDC: Ugly workaround for OpenMM using 'bar' for fundamental pressure unit.
+            # JDC: Ugly workaround for OpenMM using 'bar' for fundamental pressure unit.
             if arg.unit.is_compatible(unit.bar):
-	        arg = arg / unit.bar
+                arg = arg / unit.bar
             else:
                 arg=arg.value_in_unit_system(unit.md_unit_system)                
             # JDC: End workaround.