Changeset: 2b7efe52d82a for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB/rev/2b7efe52d82a
Modified Files:
        gdk/gdk_aggr.c
        gdk/gdk_analytic_bounds.c
        gdk/gdk_analytic_func.c
        gdk/gdk_batop.c
        gdk/gdk_calc_private.h
Branch: nilmask
Log Message:

Work in progress adding unsigned types support.


diffs (truncated from 1098 to 300 lines):

diff --git a/gdk/gdk_aggr.c b/gdk/gdk_aggr.c
--- a/gdk/gdk_aggr.c
+++ b/gdk/gdk_aggr.c
@@ -3012,8 +3012,6 @@ BATgroupavg3(BAT **avgp, BAT **remp, BAT
                }
                break;
        }
-#endif
-#ifdef HAVE_UHGE
        case TYPE_uhge: {
                const uhge *vals = (const uhge *) bi.base;
                uhge *avgs = Tloc(bn, 0);
diff --git a/gdk/gdk_analytic_bounds.c b/gdk/gdk_analytic_bounds.c
--- a/gdk/gdk_analytic_bounds.c
+++ b/gdk/gdk_analytic_bounds.c
@@ -107,19 +107,34 @@ GDKanalyticaldiff(BAT *b, BAT *p, const 
        case TYPE_bte:
                ANALYTICAL_DIFF_IMP(bte);
                break;
+       case TYPE_ubte:
+               ANALYTICAL_DIFF_IMP(ubte);
+               break;
        case TYPE_sht:
                ANALYTICAL_DIFF_IMP(sht);
                break;
+       case TYPE_usht:
+               ANALYTICAL_DIFF_IMP(usht);
+               break;
        case TYPE_int:
                ANALYTICAL_DIFF_IMP(int);
                break;
+       case TYPE_uint:
+               ANALYTICAL_DIFF_IMP(uint);
+               break;
        case TYPE_lng:
                ANALYTICAL_DIFF_IMP(lng);
                break;
+       case TYPE_ulng:
+               ANALYTICAL_DIFF_IMP(ulng);
+               break;
 #ifdef HAVE_HGE
        case TYPE_hge:
                ANALYTICAL_DIFF_IMP(hge);
                break;
+       case TYPE_uhge:
+               ANALYTICAL_DIFF_IMP(uhge);
+               break;
 #endif
        case TYPE_flt:
                if (bi.nonil) {
@@ -189,6 +204,16 @@ GDKanalyticaldiff(BAT *b, BAT *p, const 
                }                                                       \
        } while (0)
 
+#define ANALYTICAL_WINDOW_BOUNDS_ROWS_UPRECEDING(TPE, LIMIT, UPCAST)   \
+       do {                                                            \
+               j = k;                                                  \
+               for (; k < i; k++) {                                    \
+                       TPE olimit = LIMIT;                             \
+                       oid rlimit = UPCAST;                            \
+                       rb[k] = rlimit > k - j ? j : k - rlimit + second_half; \
+               }                                                       \
+       } while (0)
+
 #define ANALYTICAL_WINDOW_BOUNDS_ROWS_FOLLOWING(TPE, LIMIT, UPCAST)    \
        do {                                                            \
                for (; k < i; k++) {                                    \
@@ -200,6 +225,15 @@ GDKanalyticaldiff(BAT *b, BAT *p, const 
                }                                                       \
        } while (0)
 
+#define ANALYTICAL_WINDOW_BOUNDS_ROWS_UFOLLOWING(TPE, LIMIT, UPCAST)   \
+       do {                                                            \
+               for (; k < i; k++) {                                    \
+                       TPE olimit = LIMIT;                             \
+                       oid rlimit = UPCAST + second_half;              \
+                       rb[k] = rlimit > i - k ? i : k + rlimit;        \
+               }                                                       \
+       } while (0)
+
 #define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_ROWS(IMP, CARD, TPE, LIMIT, UPCAST) \
        do {                                                            \
                if (p) {                                                \
@@ -238,6 +272,25 @@ GDKanalyticaldiff(BAT *b, BAT *p, const 
                }                                                       \
        } while (0)
 
+#define ANALYTICAL_WINDOW_BOUNDS_GROUPS_UPRECEDING(TPE, LIMIT, UPCAST) \
+       do {                                                            \
+               oid m = k;                                              \
+               for (; k < i; k++) {                                    \
+                       TPE olimit = LIMIT;                             \
+                       oid rlimit = UPCAST;                            \
+                       for (j = k; ; j--) {                            \
+                               if (bp[j]) {                            \
+                                       if (rlimit == 0)                \
+                                               break;                  \
+                                       rlimit--;                       \
+                               }                                       \
+                               if (j == m)                             \
+                                       break;                          \
+                       }                                               \
+                       rb[k] = j;                                      \
+               }                                                       \
+       } while (0)
+
 #define ANALYTICAL_WINDOW_BOUNDS_GROUPS_FOLLOWING(TPE, LIMIT, UPCAST)  \
        do {                                                            \
                for (; k < i; k++) {                                    \
@@ -256,6 +309,22 @@ GDKanalyticaldiff(BAT *b, BAT *p, const 
                }                                                       \
        } while (0)
 
+#define ANALYTICAL_WINDOW_BOUNDS_GROUPS_UFOLLOWING(TPE, LIMIT, UPCAST) \
+       do {                                                            \
+               for (; k < i; k++) {                                    \
+                       TPE olimit = LIMIT;                             \
+                       oid rlimit = UPCAST;                            \
+                       for (j = k + 1; j < i; j++) {                   \
+                               if (bp[j]) {                            \
+                                       if (rlimit == 0)                \
+                                               break;                  \
+                                       rlimit--;                       \
+                               }                                       \
+                       }                                               \
+                       rb[k] = j;                                      \
+               }                                                       \
+       } while (0)
+
 #define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_GROUPS(IMP, CARD, TPE, LIMIT, 
UPCAST)        \
        do {                                                            \
                if (p) {                                                \
@@ -330,6 +399,26 @@ GDKanalyticaldiff(BAT *b, BAT *p, const 
                }                                                       \
        } while (0)
 
+#define ANALYTICAL_WINDOW_BOUNDS_RANGE_UPRECEDING(TPE1, LIMIT, TPE2)   \
+       do {                                                            \
+               oid m = k;                                              \
+               TPE1 v, calc;                                           \
+               for (; k < i; k++) {                                    \
+                       TPE2 olimit = LIMIT;                            \
+                       v = bp[k];                                      \
+                       for (j = k; ; j--) {                            \
+                               SUB_WITH_CHECK(v, bp[j], TPE1, calc, 
GDK_##TPE1##_max, goto calc_overflow); \
+                               if (calc > olimit) {                    \
+                                       j++;                            \
+                                       break;                          \
+                               }                                       \
+                               if (j == m)                             \
+                                       break;                          \
+                       }                                               \
+                       rb[k] = j;                                      \
+               }                                                       \
+       } while (0)
+
 #define ANALYTICAL_WINDOW_BOUNDS_RANGE_FOLLOWING(TPE1, LIMIT, TPE2)    \
        do {                                                            \
                TPE1 v, calc;                                           \
@@ -371,6 +460,21 @@ GDKanalyticaldiff(BAT *b, BAT *p, const 
                }                                                       \
        } while (0)
 
+#define ANALYTICAL_WINDOW_BOUNDS_RANGE_UFOLLOWING(TPE1, LIMIT, TPE2)   \
+       do {                                                            \
+               TPE1 v, calc;                                           \
+               for (; k < i; k++) {                                    \
+                       TPE2 olimit = LIMIT;                            \
+                       v = bp[k];                                      \
+                       for (j = k + 1; j < i; j++) {                   \
+                               SUB_WITH_CHECK(v, bp[j], TPE1, calc, 
GDK_##TPE1##_max, goto calc_overflow); \
+                               if (calc > olimit)                      \
+                                       break;                          \
+                       }                                               \
+                       rb[k] = j;                                      \
+               }                                                       \
+       } while (0)
+
 #define ANALYTICAL_WINDOW_BOUNDS_CALC_NUM(TPE1, IMP, CARD, LIMIT, TPE2)        
\
        do {                                                            \
                const TPE1 *restrict bp = (TPE1*)bi.base;               \
@@ -409,6 +513,26 @@ GDKanalyticaldiff(BAT *b, BAT *p, const 
                }                                                       \
        } while (0)
 
+#define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_UNUM(IMP, CARD, LIMIT, TPE2) \
+       do {                                                            \
+               switch (tp1) {                                          \
+               case TYPE_ubte:                                         \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_NUM(ubte, 
ANALYTICAL_WINDOW_BOUNDS_RANGE##IMP, CARD, LIMIT, TPE2); \
+                       break;                                          \
+               case TYPE_usht:                                         \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_NUM(usht, 
ANALYTICAL_WINDOW_BOUNDS_RANGE##IMP, CARD, LIMIT, TPE2); \
+                       break;                                          \
+               case TYPE_uint:                                         \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_NUM(uint, 
ANALYTICAL_WINDOW_BOUNDS_RANGE##IMP, CARD, LIMIT, TPE2); \
+                       break;                                          \
+               case TYPE_ulng:                                         \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_NUM(ulng, 
ANALYTICAL_WINDOW_BOUNDS_RANGE##IMP, CARD, LIMIT, TPE2); \
+                       break;                                          \
+               default:                                                \
+                       goto type_not_supported;                        \
+               }                                                       \
+       } while (0)
+
 #define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_FLT(IMP, CARD, LIMIT)  \
        do {                                                            \
                switch (tp1) {                                          \
@@ -454,6 +578,29 @@ GDKanalyticaldiff(BAT *b, BAT *p, const 
                        goto type_not_supported;                        \
                }                                                       \
        } while (0)
+
+#define ANALYTICAL_WINDOW_BOUNDS_BRANCHES_RANGE_UHGE(IMP, CARD, LIMIT) \
+       do {                                                            \
+               switch (tp1) {                                          \
+               case TYPE_ubte:                                         \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_NUM(ubte, 
ANALYTICAL_WINDOW_BOUNDS_RANGE##IMP, CARD, LIMIT, uhge); \
+                       break;                                          \
+               case TYPE_usht:                                         \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_NUM(usht, 
ANALYTICAL_WINDOW_BOUNDS_RANGE##IMP, CARD, LIMIT, uhge); \
+                       break;                                          \
+               case TYPE_uint:                                         \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_NUM(uint, 
ANALYTICAL_WINDOW_BOUNDS_RANGE##IMP, CARD, LIMIT, uhge); \
+                       break;                                          \
+               case TYPE_ulng:                                         \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_NUM(ulng, 
ANALYTICAL_WINDOW_BOUNDS_RANGE##IMP, CARD, LIMIT, uhge); \
+                       break;                                          \
+               case TYPE_uhge:                                         \
+                       ANALYTICAL_WINDOW_BOUNDS_CALC_NUM(uhge, 
ANALYTICAL_WINDOW_BOUNDS_RANGE##IMP, CARD, LIMIT, uhge); \
+                       break;                                          \
+               default:                                                \
+                       goto type_not_supported;                        \
+               }                                                       \
+       } while (0)
 #endif
 
 #define date_sub_month(D,M)                    date_add_month(D,-(M))
@@ -732,6 +879,13 @@ GDKanalyticalpeers(BAT *b, BAT *p, bool 
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
bte, NO_NAN_CHECK);
                }
                break;
+       case TYPE_ubte:
+               if (preceding) {
+                       ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
ubte, NO_NAN_CHECK);
+               } else {
+                       ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
ubte, NO_NAN_CHECK);
+               }
+               break;
        case TYPE_sht:
                if (preceding) {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
sht, NO_NAN_CHECK);
@@ -739,6 +893,13 @@ GDKanalyticalpeers(BAT *b, BAT *p, bool 
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
sht, NO_NAN_CHECK);
                }
                break;
+       case TYPE_usht:
+               if (preceding) {
+                       ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
usht, NO_NAN_CHECK);
+               } else {
+                       ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
usht, NO_NAN_CHECK);
+               }
+               break;
        case TYPE_int:
                if (preceding) {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
int, NO_NAN_CHECK);
@@ -746,6 +907,13 @@ GDKanalyticalpeers(BAT *b, BAT *p, bool 
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
int, NO_NAN_CHECK);
                }
                break;
+       case TYPE_uint:
+               if (preceding) {
+                       ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
uint, NO_NAN_CHECK);
+               } else {
+                       ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
uint, NO_NAN_CHECK);
+               }
+               break;
        case TYPE_lng:
                if (preceding) {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
lng, NO_NAN_CHECK);
@@ -753,6 +921,13 @@ GDKanalyticalpeers(BAT *b, BAT *p, bool 
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
lng, NO_NAN_CHECK);
                }
                break;
+       case TYPE_ulng:
+               if (preceding) {
+                       ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
ulng, NO_NAN_CHECK);
+               } else {
+                       ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
ulng, NO_NAN_CHECK);
+               }
+               break;
 #ifdef HAVE_HGE
        case TYPE_hge:
                if (preceding) {
@@ -761,6 +936,13 @@ GDKanalyticalpeers(BAT *b, BAT *p, bool 
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
hge, NO_NAN_CHECK);
                }
                break;
+       case TYPE_uhge:
+               if (preceding) {
_______________________________________________
checkin-list mailing list -- checkin-list@monetdb.org
To unsubscribe send an email to checkin-list-le...@monetdb.org

Reply via email to