[GR-9957] Various fixes for sklearn

PullRequest: graalpython/101

Author: timfel

graalpython/com.oracle.graal.python.cext/include/Python.h

@@ -61,6 +61,7 @@
 #include <langinfo.h>
 #include <assert.h>
 #include <unistd.h>
+#include <math.h>
 
 #include "pyport.h"
 #include "pymacro.h"

graalpython/com.oracle.graal.python.cext/include/pyconfig.h

@@ -11,30 +11,31 @@
 #define Py_PYCONFIG_H
 
 
-// TRUFFLE DEFS
-#define SIZEOF_DOUBLE 8
-#define SIZEOF_FLOAT 4
-#define SIZEOF_FPOS_T 16
-#define SIZEOF_INT 4
-#define SIZEOF_LONG 8
-#define SIZEOF_LONG_DOUBLE 16
-#define SIZEOF_LONG_LONG 8
-#define SIZEOF_OFF_T 8
-#define SIZEOF_PID_T 4
-#define SIZEOF_PTHREAD_T 8
-#define SIZEOF_SHORT 2
-#define SIZEOF_SIZE_T 8
-#define SIZEOF_TIME_T 8
-#define SIZEOF_UINTPTR_T 8
-#define SIZEOF_VOID_P 8
-#define SIZEOF_WCHAR_T 2
+// defines based on Clang defines
+#define SIZEOF_DOUBLE __SIZEOF_DOUBLE__
+#define SIZEOF_FLOAT __SIZEOF_FLOAT__
+#define SIZEOF_FPOS_T __SIZEOF_INT128__
+#define SIZEOF_INT __SIZEOF_INT__
+#define SIZEOF_LONG __SIZEOF_LONG__
+#define SIZEOF_LONG_DOUBLE __SIZEOF_LONG_DOUBLE__
+#define SIZEOF_LONG_LONG __SIZEOF_LONG_LONG__
+#define SIZEOF_OFF_T __SIZEOF_SIZE_T__
+#define SIZEOF_PID_T __SIZEOF_INT__
+#define SIZEOF_PTHREAD_T __SIZEOF_LONG__
+#define SIZEOF_SHORT __SIZEOF_SHORT__
+#define SIZEOF_SIZE_T __SIZEOF_SIZE_T__
+#define SIZEOF_TIME_T __SIZEOF_POINTER__
+#define SIZEOF_UINTPTR_T __SIZEOF_POINTER__
+#define SIZEOF_VOID_P __SIZEOF_POINTER__
+#define SIZEOF_WCHAR_T __SIZEOF_WCHAR_T__
 #define SIZEOF__BOOL 1
-#define INT_MIN 0x80000000
-#define INT_MAX 0x7fffffff
-#define UINT_MAX 0xffffffff
-#define SHRT_MIN 0x8000
-#define SHRT_MAX 0x7fff
-#define USHRT_MAX 0xffff
+#define INT_MIN ((-__INT32_MAX__)-1)
+#define INT_MAX __INT32_MAX__
+#define UINT_MAX __UINT32_MAX__
+#define SHRT_MIN ((-__INT16_MAX__)-1)
+#define SHRT_MAX __INT16_MAX__
+#define USHRT_MAX __UINT16_MAX__
+#define CHAR_BIT __CHAR_BIT__
 // #define Py_LIMITED_API 1
 #define _Py_BEGIN_SUPPRESS_IPH
 #define _Py_END_SUPPRESS_IPH

graalpython/com.oracle.graal.python.cext/src/unicodeobject.c

@@ -287,3 +287,34 @@ Py_UNICODE* PyUnicode_AsUnicodeAndSize(PyObject *unicode, Py_ssize_t *size) {
     }
     return NULL;
 }
+
+/* Fast detection of the most frequent whitespace characters */
+const unsigned char _Py_ascii_whitespace[] = {
+    0, 0, 0, 0, 0, 0, 0, 0,
+/*     case 0x0009: * CHARACTER TABULATION */
+/*     case 0x000A: * LINE FEED */
+/*     case 0x000B: * LINE TABULATION */
+/*     case 0x000C: * FORM FEED */
+/*     case 0x000D: * CARRIAGE RETURN */
+    0, 1, 1, 1, 1, 1, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+/*     case 0x001C: * FILE SEPARATOR */
+/*     case 0x001D: * GROUP SEPARATOR */
+/*     case 0x001E: * RECORD SEPARATOR */
+/*     case 0x001F: * UNIT SEPARATOR */
+    0, 0, 0, 0, 1, 1, 1, 1,
+/*     case 0x0020: * SPACE */
+    1, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0
+};

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

@@ -69,10 +69,6 @@
 import com.oracle.graal.python.builtins.objects.bytes.PBytes;
 import com.oracle.graal.python.builtins.objects.bytes.PIBytesLike;
 import com.oracle.graal.python.builtins.objects.cell.PCell;
-import com.oracle.graal.python.builtins.objects.cext.CExtNodes.FromNativeSubclassNode;
-import com.oracle.graal.python.builtins.objects.cext.NativeCAPISymbols;
-import com.oracle.graal.python.builtins.objects.cext.PythonNativeClass;
-import com.oracle.graal.python.builtins.objects.cext.PythonNativeObject;
 import com.oracle.graal.python.builtins.objects.common.HashingStorage.DictEntry;
 import com.oracle.graal.python.builtins.objects.common.HashingStorageNodes;
 import com.oracle.graal.python.builtins.objects.complex.PComplex;
@@ -155,6 +151,7 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.dsl.TypeSystemReference;
 import com.oracle.truffle.api.nodes.UnexpectedResultException;
+import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 
 @CoreFunctions(defineModule = "builtins")
@@ -490,11 +487,13 @@ public Object floatFromNone(PythonClass cls, @SuppressWarnings("unused") PNone a
         }
 
         @Specialization
-        Object doPythonObject(PythonClass cls, PythonObject obj,
-                        @Cached("create(__FLOAT__)") LookupAndCallUnaryNode callFloatNode) {
+        Object doPythonObject(PythonClass cls, Object obj,
+                        @Cached("create(__FLOAT__)") LookupAndCallUnaryNode callFloatNode,
+                        @Cached("create()") BranchProfile gotException) {
             try {
                 return floatFromFloat(cls, callFloatNode.executeDouble(obj));
             } catch (UnexpectedResultException e) {
+                gotException.enter();
                 Object result = e.getResult();
                 if (result == PNone.NO_VALUE) {
                     throw raise(TypeError, "must be real number, not %p", obj);
@@ -507,21 +506,6 @@ Object doPythonObject(PythonClass cls, PythonObject obj,
             }
         }
 
-        protected static FromNativeSubclassNode cacheGetFloat() {
-            return FromNativeSubclassNode.create(PythonBuiltinClassType.PFloat, NativeCAPISymbols.FUN_PY_FLOAT_AS_DOUBLE);
-        }
-
-        @Specialization
-        Object doNativeFloat(@SuppressWarnings("unused") PythonNativeClass cls, PythonNativeObject possibleBase,
-                        @Cached("cacheGetFloat()") FromNativeSubclassNode getFloat) {
-            Object convertedFloat = getFloat.execute(possibleBase);
-            if (convertedFloat instanceof Double) {
-                return possibleBase; // TODO (tfel): we really need to call back into C
-            } else {
-                throw raise(TypeError, "must be real number, not %p", possibleBase);
-            }
-        }
-
         @Fallback
         @TruffleBoundary
         public Object floatFromObject(@SuppressWarnings("unused") Object cls, Object arg) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/floats/FloatBuiltins.java

@@ -177,6 +177,21 @@ abstract static class FloatNode extends PythonUnaryBuiltinNode {
         PFloat doPFloat(PFloat self) {
             return self;
         }
+
+        protected static FromNativeSubclassNode cacheGetFloat() {
+            return FromNativeSubclassNode.create(PythonBuiltinClassType.PFloat, NativeCAPISymbols.FUN_PY_FLOAT_AS_DOUBLE);
+        }
+
+        @Specialization
+        Object doNativeFloat(PythonNativeObject possibleBase,
+                        @Cached("cacheGetFloat()") FromNativeSubclassNode getFloat) {
+            Object convertedFloat = getFloat.execute(possibleBase);
+            if (convertedFloat instanceof Double) {
+                return possibleBase;
+            } else {
+                throw raise(PythonErrorType.TypeError, "must be real number, not %p", possibleBase);
+            }
+        }
     }
 
     @Builtin(name = __ADD__, fixedNumOfArguments = 2)

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/ints/IntBuiltins.java

@@ -49,6 +49,8 @@
 import com.oracle.graal.python.builtins.objects.bytes.PBytes;
 import com.oracle.graal.python.builtins.objects.type.PythonClass;
 import com.oracle.graal.python.nodes.SpecialMethodNames;
+import com.oracle.graal.python.nodes.call.special.LookupAndCallBinaryNode;
+import com.oracle.graal.python.nodes.call.special.LookupAndCallTernaryNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinNode;
 import com.oracle.graal.python.nodes.function.builtins.PythonBinaryBuiltinNode;
@@ -60,6 +62,7 @@
 import com.oracle.graal.python.runtime.exception.PythonErrorType;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
 import com.oracle.truffle.api.dsl.NodeFactory;
@@ -607,6 +610,10 @@ abstract static class RMulNode extends MulNode {
     @TypeSystemReference(PythonArithmeticTypes.class)
     abstract static class PowNode extends PythonTernaryBuiltinNode {
 
+        protected static PowNode create() {
+            return null;
+        }
+
         @Specialization(guards = "right >= 0", rewriteOn = ArithmeticException.class)
         int doIntegerFast(int left, int right, @SuppressWarnings("unused") PNone none) {
             int result = 1;
@@ -688,6 +695,28 @@ PInt doPInt(PInt left, PInt right, @SuppressWarnings("unused") PNone none) {
             return factory().createInt((long) value);
         }
 
+        @Specialization
+        Object powModulo(Object x, Object y, long z,
+                        @Cached("create(__POW__)") LookupAndCallTernaryNode powNode,
+                        @Cached("create(__MOD__)") LookupAndCallBinaryNode modNode) {
+            Object result = powNode.execute(x, y, PNone.NO_VALUE);
+            if (result == PNotImplemented.NOT_IMPLEMENTED) {
+                return result;
+            }
+            return modNode.executeObject(result, z);
+        }
+
+        @Specialization
+        Object powModuloPInt(Object x, Object y, PInt z,
+                        @Cached("create(__POW__)") LookupAndCallTernaryNode powNode,
+                        @Cached("create(__MOD__)") LookupAndCallBinaryNode modNode) {
+            Object result = powNode.execute(x, y, PNone.NO_VALUE);
+            if (result == PNotImplemented.NOT_IMPLEMENTED) {
+                return result;
+            }
+            return modNode.executeObject(result, z);
+        }
+
         @Fallback
         @SuppressWarnings("unused")
         Object doFallback(Object x, Object y, Object z) {

graalpython/lib-graalpython/_sre.py

@@ -58,6 +58,7 @@ def TREGEX_ENGINE(*args): raise e
 class SRE_Match():
     def __init__(self, pattern, pos, endpos, result):
         self.result = result
+        self.compiled_regex = result.regex
         self.re = pattern
         self.pos = pos
         self.endpos = endpos
@@ -67,26 +68,49 @@ def end(self, groupnum=0):
 
     def group(self, *args):
         if not args:
-            return self.result.input[self.result.start[0]:self.result.end[0]]
+            return self.__group__(0)
         elif len(args) == 1:
-            return self.result.input[self.result.start[args[0]]:self.result.end[args[0]]]
+            return self.__group__(args[0])
         else:
             lst = []
             for arg in args:
-                lst.append(self.result.input[self.result.start[arg]:self.result.end[arg]])
+                lst.append(self.__group__(arg))
             return tuple(lst)
 
     def groups(self, default=None):
         lst = []
         for arg in range(1, self.result.groupCount):
-            lst.append(self.result.input[self.result.start[arg]:self.result.end[arg]])
+            lst.append(self.__group__(arg))
         return tuple(lst)
 
+    def __groupidx__(self, idx):
+        if isinstance(idx, str):
+            return self.compiled_regex.groups[idx]
+        else:
+            return idx
+
+    def __group__(self, idx):
+        idxarg = self.__groupidx__(idx)
+        start = self.result.start[idxarg]
+        if start < 0:
+            return None
+        else:
+            return self.result.input[start:self.result.end[idxarg]]
+
+    def groupdict(self, default=None):
+        d = {}
+        for k in self.compiled_regex.groups:
+            idx = self.compiled_regex.groups[k]
+            d[k] = self.__group__(idx)
+        return d
+
     def span(self, groupnum=0):
-        return (self.result.start[groupnum], self.result.end[groupnum])
+        idxarg = self.__groupidx__(groupnum)
+        return (self.result.start[idxarg], self.result.end[idxarg])
 
     def start(self, groupnum=0):
-        return self.result.start[groupnum]
+        idxarg = self.__groupidx__(groupnum)
+        return self.result.start[idxarg]
 
     @property
     def string(self):

graalpython/lib-graalpython/sys.py

@@ -73,6 +73,7 @@ def make_flags_class():
 flags = make_flags_class()(flags)
 del make_flags_class
 
+
 def make_float_info_class():
     from _descriptor import make_named_tuple_class
     return make_named_tuple_class(
@@ -93,6 +94,26 @@ def make_float_info_class():
 del make_float_info_class
 
 
+def make_hash_info_class():
+    from _descriptor import make_named_tuple_class
+    return make_named_tuple_class(
+        "hash_info",
+        ["algorithm",
+         "cutoff",
+         "hash_bits",
+         "imag",
+         "inf",
+         "modulus",
+         "nan",
+         "seed_bits",
+         "width"]
+    )
+hash_info = make_hash_info_class()(
+    ("java", 0, 64, 0, float('inf').__hash__(), 7, float('nan').__hash__(), 0, 64)
+)
+del make_hash_info_class
+
+
 meta_path = []
 path_hooks = []
 path_importer_cache = {}