Changeset: f61a82153805 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=f61a82153805
Modified Files:
clients/Tests/MAL-signatures.stable.out
clients/Tests/MAL-signatures.stable.out.int128
clients/Tests/exports.stable.out
gdk/ChangeLog.Nov2019
gdk/gdk_calc.c
gdk/gdk_calc.h
monetdb5/modules/mal/00_batcalc_hge.mal
monetdb5/modules/mal/00_batcalc_hge.mal.sh
monetdb5/modules/mal/01_batcalc.mal
monetdb5/modules/mal/01_batcalc.mal.sh
monetdb5/modules/mal/01_calc.mal
monetdb5/modules/mal/01_calc.mal.sh
monetdb5/modules/mal/batcalc.c
monetdb5/modules/mal/calc.c
sql/common/sql_types.c
sql/server/rel_optimizer.c
sql/test/emptydb-upgrade-chain-hge/Tests/upgrade.stable.out.int128
sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out
sql/test/emptydb-upgrade-chain/Tests/upgrade.stable.out.int128
sql/test/emptydb-upgrade-hge/Tests/upgrade.stable.out.int128
sql/test/emptydb-upgrade/Tests/upgrade.stable.out
sql/test/emptydb-upgrade/Tests/upgrade.stable.out.int128
sql/test/emptydb/Tests/check.stable.out
sql/test/emptydb/Tests/check.stable.out.32bit
sql/test/emptydb/Tests/check.stable.out.int128
sql/test/testdb-upgrade-chain-hge/Tests/upgrade.stable.out.int128
sql/test/testdb-upgrade-chain/Tests/upgrade.stable.out
sql/test/testdb-upgrade-chain/Tests/upgrade.stable.out.int128
sql/test/testdb-upgrade-hge/Tests/upgrade.stable.out.int128
sql/test/testdb-upgrade/Tests/upgrade.stable.out
sql/test/testdb-upgrade/Tests/upgrade.stable.out.int128
Branch: Nov2019
Log Message:
Implemented "anti" parameter in BATcalcbetween and variants.
diffs (truncated from 114148 to 300 lines):
diff --git a/clients/Tests/MAL-signatures.stable.out
b/clients/Tests/MAL-signatures.stable.out
--- a/clients/Tests/MAL-signatures.stable.out
+++ b/clients/Tests/MAL-signatures.stable.out
@@ -6117,14 +6117,14 @@ stdout of test 'MAL-signatures` in direc
[ "batcalc", "avg", "pattern batcalc.avg(b:bat[:sht], s:bat[:oid],
scale:int):dbl ", "CMDcalcavg;", "average of non-nil values of B"
]
[ "batcalc", "avg", "pattern batcalc.avg(b:bat[:sht], scale:int) (X_0:dbl,
X_1:lng) ", "CMDcalcavg;", "average and number of non-nil values of B"
]
[ "batcalc", "avg", "pattern batcalc.avg(b:bat[:sht], scale:int):dbl ",
"CMDcalcavg;", "average of non-nil values of B with candidates list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:any_1, s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2
(or vice versa) with candidate list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:any_1, sym:bit, linc:bit, hinc:bit, nils_false:bit):bat[:bit] ",
"CMDbatBETWEEN;", "B between V1 and V2 (or vice versa)" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:bat[:any_1], s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and
V2 (or vice versa) with candidate list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:bat[:any_1], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2
(or vice versa)" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:any_1, s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and
V2 (or vice versa) with candidate list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:any_1, sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2
(or vice versa)" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:bat[:any_1], s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or
vice versa) with candidate list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:bat[:any_1], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2
(or vice versa)" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:any_1, s:bat[:oid], sym:bit, linc:bit, hinc:bit, nils_false:bit,
anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or vice
versa) with candidate list" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:any_1, sym:bit, linc:bit, hinc:bit, nils_false:bit,
anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or vice
versa)" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:bat[:any_1], s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit, anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between
V1 and V2 (or vice versa) with candidate list" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:bat[:any_1], sym:bit, linc:bit, hinc:bit, nils_false:bit,
anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or vice
versa)" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:any_1, s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit, anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between
V1 and V2 (or vice versa) with candidate list" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:any_1, sym:bit, linc:bit, hinc:bit, nils_false:bit,
anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or vice
versa)" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:bat[:any_1], s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit, anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B
between V1 and V2 (or vice versa) with candidate list" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:bat[:any_1], sym:bit, linc:bit, hinc:bit, nils_false:bit,
anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or
vice versa)" ]
[ "batcalc", "bit", "pattern batcalc.bit(b:bat[:bit]):bat[:bit] ",
"CMDconvertsignal_bit;", "cast from bit to bit, signal error on
overflow" ]
[ "batcalc", "bit", "pattern batcalc.bit(b:bat[:bit],
s:bat[:oid]):bat[:bit] ", "CMDconvertsignal_bit;", "cast from bit to
bit with candidates list, signal error on overflow" ]
[ "batcalc", "bit", "pattern batcalc.bit(b:bat[:bte]):bat[:bit] ",
"CMDconvertsignal_bit;", "cast from bte to bit, signal error on
overflow" ]
@@ -10066,7 +10066,7 @@ stdout of test 'MAL-signatures` in direc
[ "calc", "and", "pattern calc.and(v1:int, v2:int):int ",
"CMDvarAND;", "Return V1 AND V2" ]
[ "calc", "and", "pattern calc.and(v1:lng, v2:lng):lng ",
"CMDvarAND;", "Return V1 AND V2" ]
[ "calc", "and", "pattern calc.and(v1:sht, v2:sht):sht ",
"CMDvarAND;", "Return V1 AND V2" ]
-[ "calc", "between", "pattern calc.between(b:any_1, lo:any_1,
hi:any_1, sym:bit, linc:bit, hinc:bit, nils_false:bit):bit ",
"CMDvarBETWEEN;", "B between LO and HI inclusive" ]
+[ "calc", "between", "pattern calc.between(b:any_1, lo:any_1,
hi:any_1, sym:bit, linc:bit, hinc:bit, nils_false:bit, anti:bit):bit ",
"CMDvarBETWEEN;", "B between LO and HI inclusive" ]
[ "calc", "bit", "pattern calc.bit(v:bit):bit ", "CMDvarCONVERT;",
"Cast VALUE to bit" ]
[ "calc", "bit", "pattern calc.bit(v:bte):bit ", "CMDvarCONVERT;",
"Cast VALUE to bit" ]
[ "calc", "bit", "pattern calc.bit(v:dbl):bit ", "CMDvarCONVERT;",
"Cast VALUE to bit" ]
diff --git a/clients/Tests/MAL-signatures.stable.out.int128
b/clients/Tests/MAL-signatures.stable.out.int128
--- a/clients/Tests/MAL-signatures.stable.out.int128
+++ b/clients/Tests/MAL-signatures.stable.out.int128
@@ -8651,22 +8651,14 @@ stdout of test 'MAL-signatures` in direc
[ "batcalc", "avg", "pattern batcalc.avg(b:bat[:sht], s:bat[:oid],
scale:int):dbl ", "CMDcalcavg;", "average of non-nil values of B"
]
[ "batcalc", "avg", "pattern batcalc.avg(b:bat[:sht], scale:int) (X_0:dbl,
X_1:lng) ", "CMDcalcavg;", "average and number of non-nil values of B"
]
[ "batcalc", "avg", "pattern batcalc.avg(b:bat[:sht], scale:int):dbl ",
"CMDcalcavg;", "average of non-nil values of B with candidates list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:any_1, s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2
(or vice versa) with candidate list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:any_1, sym:bit, linc:bit, hinc:bit, nils_false:bit):bat[:bit] ",
"CMDbatBETWEEN;", "B between V1 and V2 (or vice versa)" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:bat[:any_1], s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and
V2 (or vice versa) with candidate list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:bat[:any_1], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2
(or vice versa)" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:any_1, s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and
V2 (or vice versa) with candidate list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:any_1, sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2
(or vice versa)" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:bat[:any_1], s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or
vice versa) with candidate list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:bat[:any_1], sym:bit, linc:bit, hinc:bit,
nils_false:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2
(or vice versa)" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:hge],
lo:bat[:hge], hi:bat[:hge]):bat[:bit] ", "CMDbatBETWEEN;", "B between LO
and HI inclusive, nil border is (minus) infinity" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:hge],
lo:bat[:hge], hi:bat[:hge], s:bat[:oid]):bat[:bit] ", "CMDbatBETWEEN;",
"B between LO and HI inclusive with candidates list, nil border is (minus)
infinity" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:hge],
lo:bat[:hge], hi:hge):bat[:bit] ", "CMDbatBETWEEN;", "B between LO
and HI inclusive, nil border is (minus) infinity" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:hge],
lo:bat[:hge], hi:hge, s:bat[:oid]):bat[:bit] ", "CMDbatBETWEEN;", "B
between LO and HI inclusive with candidates list, nil border is (minus)
infinity" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:hge], lo:hge,
hi:bat[:hge]):bat[:bit] ", "CMDbatBETWEEN;", "B between LO and HI
inclusive, nil border is (minus) infinity" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:hge], lo:hge,
hi:bat[:hge], s:bat[:oid]):bat[:bit] ", "CMDbatBETWEEN;", "B between LO
and HI inclusive with candidates list, nil border is (minus) infinity" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:hge], lo:hge,
hi:hge):bat[:bit] ", "CMDbatBETWEEN;", "B between LO and HI
inclusive, nil border is (minus) infinity" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:hge], lo:hge,
hi:hge, s:bat[:oid]):bat[:bit] ", "CMDbatBETWEEN;", "B between LO and HI
inclusive with candidates list, nil border is (minus) infinity" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:any_1, s:bat[:oid], sym:bit, linc:bit, hinc:bit, nils_false:bit,
anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or vice
versa) with candidate list" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:any_1, sym:bit, linc:bit, hinc:bit, nils_false:bit,
anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or vice
versa)" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:bat[:any_1], s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit, anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between
V1 and V2 (or vice versa) with candidate list" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:any_1, v2:bat[:any_1], sym:bit, linc:bit, hinc:bit, nils_false:bit,
anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or vice
versa)" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:any_1, s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit, anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between
V1 and V2 (or vice versa) with candidate list" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:any_1, sym:bit, linc:bit, hinc:bit, nils_false:bit,
anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or vice
versa)" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:bat[:any_1], s:bat[:oid], sym:bit, linc:bit, hinc:bit,
nils_false:bit, anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B
between V1 and V2 (or vice versa) with candidate list" ]
+[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
v1:bat[:any_1], v2:bat[:any_1], sym:bit, linc:bit, hinc:bit, nils_false:bit,
anti:bit):bat[:bit] ", "CMDbatBETWEEN;", "B between V1 and V2 (or
vice versa)" ]
[ "batcalc", "bit", "pattern batcalc.bit(b:bat[:bit]):bat[:bit] ",
"CMDconvertsignal_bit;", "cast from bit to bit, signal error on
overflow" ]
[ "batcalc", "bit", "pattern batcalc.bit(b:bat[:bit],
s:bat[:oid]):bat[:bit] ", "CMDconvertsignal_bit;", "cast from bit to
bit with candidates list, signal error on overflow" ]
[ "batcalc", "bit", "pattern batcalc.bit(b:bat[:bte]):bat[:bit] ",
"CMDconvertsignal_bit;", "cast from bte to bit, signal error on
overflow" ]
@@ -14218,7 +14210,7 @@ stdout of test 'MAL-signatures` in direc
[ "calc", "and", "pattern calc.and(v1:int, v2:int):int ",
"CMDvarAND;", "Return V1 AND V2" ]
[ "calc", "and", "pattern calc.and(v1:lng, v2:lng):lng ",
"CMDvarAND;", "Return V1 AND V2" ]
[ "calc", "and", "pattern calc.and(v1:sht, v2:sht):sht ",
"CMDvarAND;", "Return V1 AND V2" ]
-[ "calc", "between", "pattern calc.between(b:any_1, lo:any_1,
hi:any_1, sym:bit, linc:bit, hinc:bit, nils_false:bit):bit ",
"CMDvarBETWEEN;", "B between LO and HI inclusive" ]
+[ "calc", "between", "pattern calc.between(b:any_1, lo:any_1,
hi:any_1, sym:bit, linc:bit, hinc:bit, nils_false:bit, anti:bit):bit ",
"CMDvarBETWEEN;", "B between LO and HI inclusive" ]
[ "calc", "bit", "pattern calc.bit(v:bit):bit ", "CMDvarCONVERT;",
"Cast VALUE to bit" ]
[ "calc", "bit", "pattern calc.bit(v:bte):bit ", "CMDvarCONVERT;",
"Cast VALUE to bit" ]
[ "calc", "bit", "pattern calc.bit(v:dbl):bit ", "CMDvarCONVERT;",
"Cast VALUE to bit" ]
diff --git a/clients/Tests/exports.stable.out b/clients/Tests/exports.stable.out
--- a/clients/Tests/exports.stable.out
+++ b/clients/Tests/exports.stable.out
@@ -27,10 +27,10 @@ BAT *BATcalcaddcst(BAT *b, const ValReco
BAT *BATcalcand(BAT *b1, BAT *b2, BAT *s);
BAT *BATcalcandcst(BAT *b, const ValRecord *v, BAT *s);
gdk_return BATcalcavg(BAT *b, BAT *s, dbl *avg, BUN *vals, int scale);
-BAT *BATcalcbetween(BAT *b, BAT *lo, BAT *hi, BAT *s, bool symmetric, bool
linc, bool hinc, bool nils_false);
-BAT *BATcalcbetweenbatcst(BAT *b, BAT *lo, const ValRecord *hi, BAT *s, bool
symmetric, bool linc, bool hinc, bool nils_false);
-BAT *BATcalcbetweencstbat(BAT *b, const ValRecord *lo, BAT *hi, BAT *s, bool
symmetric, bool linc, bool hinc, bool nils_false);
-BAT *BATcalcbetweencstcst(BAT *b, const ValRecord *lo, const ValRecord *hi,
BAT *s, bool symmetric, bool linc, bool hinc, bool nils_false);
+BAT *BATcalcbetween(BAT *b, BAT *lo, BAT *hi, BAT *s, bool symmetric, bool
linc, bool hinc, bool nils_false, bool anti);
+BAT *BATcalcbetweenbatcst(BAT *b, BAT *lo, const ValRecord *hi, BAT *s, bool
symmetric, bool linc, bool hinc, bool nils_false, bool anti);
+BAT *BATcalcbetweencstbat(BAT *b, const ValRecord *lo, BAT *hi, BAT *s, bool
symmetric, bool linc, bool hinc, bool nils_false, bool anti);
+BAT *BATcalcbetweencstcst(BAT *b, const ValRecord *lo, const ValRecord *hi,
BAT *s, bool symmetric, bool linc, bool hinc, bool nils_false, bool anti);
BAT *BATcalccmp(BAT *b1, BAT *b2, BAT *s);
BAT *BATcalccmpcst(BAT *b, const ValRecord *v, BAT *s);
BAT *BATcalccstadd(const ValRecord *v, BAT *b, BAT *s, int tp, bool
abort_on_error);
@@ -359,7 +359,7 @@ ValPtr VALset(ValPtr v, int t, void *p);
gdk_return VARcalcabsolute(ValPtr ret, const ValRecord *v);
gdk_return VARcalcadd(ValPtr ret, const ValRecord *lft, const ValRecord *rgt,
bool abort_on_error);
gdk_return VARcalcand(ValPtr ret, const ValRecord *lft, const ValRecord *rgt);
-gdk_return VARcalcbetween(ValPtr ret, const ValRecord *v, const ValRecord *lo,
const ValRecord *hi, bool symmetric, bool linc, bool hinc, bool nils_false);
+gdk_return VARcalcbetween(ValPtr ret, const ValRecord *v, const ValRecord *lo,
const ValRecord *hi, bool symmetric, bool linc, bool hinc, bool nils_false,
bool anti);
gdk_return VARcalccmp(ValPtr ret, const ValRecord *lft, const ValRecord *rgt);
gdk_return VARcalcdecr(ValPtr ret, const ValRecord *v, bool abort_on_error);
gdk_return VARcalcdiv(ValPtr ret, const ValRecord *lft, const ValRecord *rgt,
bool abort_on_error);
diff --git a/gdk/ChangeLog.Nov2019 b/gdk/ChangeLog.Nov2019
--- a/gdk/ChangeLog.Nov2019
+++ b/gdk/ChangeLog.Nov2019
@@ -1,6 +1,10 @@
# ChangeLog file for MonetDB
# This file is updated with Maddlog
+* Sun Sep 8 2019 Sjoerd Mullender <sjo...@acm.org>
+- BATcalcbetween and all its variants now have an extra bool parameter
+ "anti" to invert the test.
+
* Thu Apr 18 2019 Sjoerd Mullender <sjo...@acm.org>
- All forms of BATcalcbetween and VARcalcbetween have extra bool arguments
for low inclusive, high inclusive and nils false. The latter causes
diff --git a/gdk/gdk_calc.c b/gdk/gdk_calc.c
--- a/gdk/gdk_calc.c
+++ b/gdk/gdk_calc.c
@@ -12762,11 +12762,11 @@ VARcalcrsh(ValPtr ret, const ValRecord *
? nils_false ? 0 : (nils++, bit_nil) \
: (is_##TYPE##_nil(lo) || is_##TYPE##_nil(hi) \
? (nils++, bit_nil) \
- : (bit) ((((lo) < (v) || (linc && (lo) == (v))) && \
- ((v) < (hi) || (hinc && (v) == (hi)))) || \
- (symmetric && \
- ((hi) < (v) || (hinc && (hi) == (v))) && \
- ((v) < (lo) || (linc && (v) == (lo)))))))
+ : (bit) (((((lo) < (v) || (linc && (lo) == (v))) && \
+ ((v) < (hi) || (hinc && (v) == (hi)))) || \
+ (symmetric && \
+ ((hi) < (v) || (hinc && (hi) == (v))) && \
+ ((v) < (lo) || (linc && (v) == (lo))))) ^ anti)))
#define BETWEEN_LOOP_TYPE(TYPE)
\
do { \
@@ -12790,7 +12790,7 @@ BATcalcbetween_intern(const void *src, i
const void *hi, int incr3, const char *hp3, int wd3,
int tp, BUN cnt, BUN start, BUN end,
const oid *restrict cand, const oid *candend,
- oid seqbase, bool symmetric,
+ oid seqbase, bool symmetric, bool anti,
bool linc, bool hinc, bool nils_false, const char *func)
{
BAT *bn;
@@ -12879,15 +12879,16 @@ BATcalcbetween_intern(const void *src, i
} else {
int c;
dst[l] = (bit)
- ((((c = (*atomcmp)(p1, p2)) > 0
- || (linc && c == 0))
- && ((c = (*atomcmp)(p1, p3)) < 0
- || (hinc && c == 0)))
- || (symmetric
- && ((c = (*atomcmp)(p1, p3)) > 0
- || (hinc && c == 0))
- && ((c = (*atomcmp)(p1, p2)) < 0
- || (linc && c == 0))));
+ (((((c = (*atomcmp)(p1, p2)) > 0
+ || (linc && c == 0))
+ && ((c = (*atomcmp)(p1, p3)) < 0
+ || (hinc && c == 0)))
+ || (symmetric
+ && ((c = (*atomcmp)(p1, p3)) > 0
+ || (hinc && c == 0))
+ && ((c = (*atomcmp)(p1, p2)) < 0
+ || (linc && c == 0))))
+ ^ anti);
}
}
break;
@@ -12908,7 +12909,7 @@ BATcalcbetween_intern(const void *src, i
BAT *
BATcalcbetween(BAT *b, BAT *lo, BAT *hi, BAT *s, bool symmetric,
- bool linc, bool hinc, bool nils_false)
+ bool linc, bool hinc, bool nils_false, bool anti)
{
BAT *bn;
BUN start, end, cnt;
@@ -12936,15 +12937,16 @@ BATcalcbetween(BAT *b, BAT *lo, BAT *hi,
res = bit_nil;
else
res = (bit)
- (((b->tseqbase > lo->tseqbase ||
- (linc && b->tseqbase == lo->tseqbase)) &&
- (b->tseqbase < hi->tseqbase ||
- (hinc && b->tseqbase == hi->tseqbase))) ||
- (symmetric &&
- (b->tseqbase > hi->tseqbase ||
- (hinc && b->tseqbase == hi->tseqbase)) &&
- (b->tseqbase < lo->tseqbase ||
- (linc && b->tseqbase == lo->tseqbase))));
+ ((((b->tseqbase > lo->tseqbase ||
+ (linc && b->tseqbase == lo->tseqbase)) &&
+ (b->tseqbase < hi->tseqbase ||
+ (hinc && b->tseqbase == hi->tseqbase))) ||
+ (symmetric &&
+ (b->tseqbase > hi->tseqbase ||
+ (hinc && b->tseqbase == hi->tseqbase)) &&
+ (b->tseqbase < lo->tseqbase ||
+ (linc && b->tseqbase == lo->tseqbase))))
+ ^ anti);
return BATconstant(b->hseqbase, TYPE_bit, &res, BATcount(b),
TRANSIENT);
@@ -12961,7 +12963,7 @@ BATcalcbetween(BAT *b, BAT *lo, BAT *hi,
hi->twidth,
b->ttype, cnt,
start, end, cand, candend,
- b->hseqbase, symmetric, linc, hinc,
+ b->hseqbase, symmetric, anti, linc, hinc,
nils_false, "BATcalcbetween");
return bn;
@@ -12969,7 +12971,8 @@ BATcalcbetween(BAT *b, BAT *lo, BAT *hi,
BAT *
BATcalcbetweencstcst(BAT *b, const ValRecord *lo, const ValRecord *hi, BAT *s,
- bool symmetric, bool linc, bool hinc, bool nils_false)
+ bool symmetric, bool linc, bool hinc, bool nils_false,
+ bool anti)
{
BAT *bn;
BUN start, end, cnt;
@@ -12992,7 +12995,7 @@ BATcalcbetweencstcst(BAT *b, const ValRe
VALptr(hi), 0, NULL, 0,
b->ttype, cnt,
start, end, cand, candend,
- b->hseqbase, symmetric,
+ b->hseqbase, symmetric, anti,
linc, hinc, nils_false,
"BATcalcbetweencstcst");
@@ -13001,7 +13004,8 @@ BATcalcbetweencstcst(BAT *b, const ValRe
BAT *
BATcalcbetweenbatcst(BAT *b, BAT *lo, const ValRecord *hi, BAT *s,
- bool symmetric, bool linc, bool hinc, bool nils_false)
+ bool symmetric, bool linc, bool hinc, bool nils_false,
+ bool anti)
{
BAT *bn;
BUN start, end, cnt;
@@ -13029,7 +13033,7 @@ BATcalcbetweenbatcst(BAT *b, BAT *lo, co
VALptr(hi), 0, NULL, 0,
b->ttype, cnt,
start, end, cand, candend,
- b->hseqbase, symmetric,
+ b->hseqbase, symmetric, anti,
linc, hinc, nils_false,
"BATcalcbetweenbatcst");
@@ -13038,7 +13042,8 @@ BATcalcbetweenbatcst(BAT *b, BAT *lo, co
BAT *
BATcalcbetweencstbat(BAT *b, const ValRecord *lo, BAT *hi, BAT *s,
- bool symmetric, bool linc, bool hinc, bool nils_false)
+ bool symmetric, bool linc, bool hinc, bool nils_false,
+ bool anti)
{
BAT *bn;
BUN start, end, cnt;
@@ -13066,7 +13071,7 @@ BATcalcbetweencstbat(BAT *b, const ValRe
hi->twidth,
b->ttype, cnt,
start, end, cand, candend,
- b->hseqbase, symmetric,
+ b->hseqbase, symmetric, anti,
linc, hinc, nils_false,
"BATcalcbetweencstbat");
@@ -13076,7 +13081,7 @@ BATcalcbetweencstbat(BAT *b, const ValRe
gdk_return
VARcalcbetween(ValPtr ret, const ValRecord *v, const ValRecord *lo,
const ValRecord *hi, bool symmetric, bool linc, bool hinc,
- bool nils_false)
+ bool nils_false, bool anti)
{
BUN nils = 0; /* to make reusing BETWEEN macro easier */
int t;
@@ -13130,16 +13135,17 @@ VARcalcbetween(ValPtr ret, const ValReco
ret->val.btval = bit_nil;
else {
int c;
- ret->val.btval =
- (bit) ((((c = atomcmp(VALptr(v), VALptr(lo))) >
0 ||
- (linc && c == 0)) &&
- ((c = atomcmp(VALptr(v), VALptr(hi)) <
0 ||
- (hinc && c == 0)))) ||
- (symmetric &&
- ((c = atomcmp(VALptr(v), VALptr(hi))) >
0 ||
- (hinc && c == 0)) &&
- ((c = atomcmp(VALptr(v), VALptr(lo))) <
0 ||
- (linc && c == 0))));
+ ret->val.btval = (bit)
+ (((((c = atomcmp(VALptr(v), VALptr(lo))) > 0 ||
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list
