Formatting

Author: ppisl

graalpython/com.oracle.graal.python.test/src/tests/test_math.py

@@ -125,8 +125,8 @@ def result_check(expected, got, ulp_tol=5, abs_tol=0.0):
         return None
 
 class MyFloat:
-            def __float__(self):
-                return 0.6
+    def __float__(self):
+        return 0.6
 
 class MathTests(unittest.TestCase):
 
@@ -143,6 +143,14 @@ def ftest(self, name, got, expected, ulp_tol=5, abs_tol=0.0):
         if failure is not None:
             self.fail("{}: {}".format(name, failure))
 
+    def testConstants(self):
+        # Ref: Abramowitz & Stegun (Dover, 1965)
+        self.ftest('pi', math.pi, 3.141592653589793238462643)
+        self.ftest('e', math.e, 2.718281828459045235360287)
+        if (sys.version_info.major >= 3 and sys.version_info.minor >= 6):
+            # math.tau since 3.6
+            self.assertEqual(math.tau, 2*math.pi)
+
     def testAcos(self):
         self.assertRaises(TypeError, math.acos)
         self.ftest('acos(-1)', math.acos(-1), math.pi)
@@ -285,14 +293,6 @@ def testIsinf(self):
         self.assertFalse(math.isinf(BIG_INT))
         self.assertRaises(TypeError, math.isinf, 'ahoj')
         self.assertFalse(math.isinf(MyFloat()))
-        
-    def testConstants(self):
-        # Ref: Abramowitz & Stegun (Dover, 1965)
-        self.ftest('pi', math.pi, 3.141592653589793238462643)
-        self.ftest('e', math.e, 2.718281828459045235360287)
-        if (sys.version_info.major >= 3 and sys.version_info.minor >= 6):
-            # math.tau since 3.6
-            self.assertEqual(math.tau, 2*math.pi)
 
     def test_ceil_basic(self):
         self.assertEqual(math.ceil(10), 10)

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/MathModuleBuiltins.java

@@ -1158,31 +1158,31 @@ public abstract static class LogNode extends PythonUnaryBuiltinNode {
         @Child private LookupAndCallUnaryNode valueDispatchNode;
         @Child private LookupAndCallUnaryNode baseDispatchNode;
         @Child private LogNode recLogNode;
-        
+
         private LookupAndCallUnaryNode getValueDispatchNode() {
             if (valueDispatchNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
                 valueDispatchNode = insert(LookupAndCallUnaryNode.create(SpecialMethodNames.__FLOAT__));
             }
             return valueDispatchNode;
         }
-        
+
         private LookupAndCallUnaryNode getBaseDispatchNode() {
             if (baseDispatchNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
                 baseDispatchNode = insert(LookupAndCallUnaryNode.create(SpecialMethodNames.__FLOAT__));
             }
             return baseDispatchNode;
         }
-        
+
         private double executeRecursiveLogNode(Object value, Object base) {
             if (recLogNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
                 recLogNode = insert(LogNode.create());
             }
             return recLogNode.executeObject(value, base);
         }
-        
+
         public abstract double executeObject(Object value, Object base);
 
         private static final double LOG2 = Math.log(2.0);
@@ -1210,7 +1210,7 @@ private double countBase(BigInteger base, ConditionProfile divByZero) {
             }
             return logBase;
         }
-   
+
         @Specialization
         public double log(long value, @SuppressWarnings("unused") PNone novalue,
                         @Cached("createBinaryProfile()") ConditionProfile doNotFit) {
@@ -1345,18 +1345,18 @@ public double logDO(double value, Object base,
         }
 
         @Specialization(guards = {"!isNumber(base)"})
-        public double logPIO(PInt value, Object base, 
+        public double logPIO(PInt value, Object base,
                         @Cached("createBinaryProfile()") ConditionProfile notNumberBase) {
             Object resultBase = getRealNumber(base, getBaseDispatchNode(), notNumberBase);
             return executeRecursiveLogNode(value, resultBase);
         }
-        
+
         private void raiseMathError(ConditionProfile doNotFit, boolean con) {
             if (doNotFit.profile(con)) {
                 throw raise(ValueError, "math domain error");
             }
         }
-        
+
         private Object getRealNumber(Object object, LookupAndCallUnaryNode dispatchNode, ConditionProfile isNotRealNumber) {
             Object result = dispatchNode.executeObject(object);
             if (result == PNone.NO_VALUE) {