Changeset: 7f0b724a589b for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=7f0b724a589b
Modified Files:
clients/Tests/MAL-signatures.stable.out
clients/Tests/MAL-signatures.stable.out.int128
clients/Tests/exports.stable.out
gdk/gdk_calc.c
gdk/gdk_calc.h
monetdb5/modules/mal/00_batcalc_hge.mal.sh
monetdb5/modules/mal/00_calc_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
monetdb5/optimizer/opt_prelude.c
monetdb5/optimizer/opt_prelude.h
sql/backends/monet5/sql_statement.c
Branch: default
Log Message:
Implemented low/high inclusive flags in (bat)calc.between.
Also removed separate (bat)calc.between_symmetric: always specify all
flags in the (bat)calc.between call.
diffs (truncated from 851 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
@@ -6108,22 +6108,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],
lo:any_1, hi:any_1):bat[:bit] ", "CMDbatBETWEEN;", "B between LO
and HI inclusive" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:any_1, hi:any_1, s:bat[:oid]):bat[:bit] ", "CMDbatBETWEEN;", "B
between LO and HI inclusive with candidates list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:any_1, hi:bat[:any_1]):bat[:bit] ", "CMDbatBETWEEN;", "B between LO
and HI inclusive" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:any_1, hi:bat[:any_1], s:bat[:oid]):bat[:bit] ", "CMDbatBETWEEN;",
"B between LO and HI inclusive with candidates list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:bat[:any_1], hi:any_1):bat[:bit] ", "CMDbatBETWEEN;", "B between LO
and HI inclusive" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:bat[:any_1], hi:any_1, s:bat[:oid]):bat[:bit] ", "CMDbatBETWEEN;",
"B between LO and HI inclusive with candidates list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:bat[:any_1], hi:bat[:any_1]):bat[:bit] ", "CMDbatBETWEEN;", "B
between LO and HI inclusive" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:bat[:any_1], hi:bat[:any_1], s:bat[:oid]):bat[:bit] ",
"CMDbatBETWEEN;", "B between LO and HI inclusive with candidates list"
]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:any_1, v2:any_1):bat[:bit] ",
"CMDbatBETWEENsymmetric;", "B between V1 and V2 (or vice versa) inclusive"
]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:any_1, v2:any_1,
s:bat[:oid]):bat[:bit] ", "CMDbatBETWEENsymmetric;", "B between V1 and V2
(or vice versa) inclusive with candidates list" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:any_1, v2:bat[:any_1]):bat[:bit] ",
"CMDbatBETWEENsymmetric;", "B between V1 and V2 (or vice versa)
inclusive" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:any_1, v2:bat[:any_1],
s:bat[:oid]):bat[:bit] ", "CMDbatBETWEENsymmetric;", "B between V1 and
V2 (or vice versa) inclusive with candidates list" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:bat[:any_1], v2:any_1):bat[:bit] ",
"CMDbatBETWEENsymmetric;", "B between V1 and V2 (or vice versa)
inclusive" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:bat[:any_1], v2:any_1,
s:bat[:oid]):bat[:bit] ", "CMDbatBETWEENsymmetric;", "B between V1 and
V2 (or vice versa) inclusive with candidates list" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:bat[:any_1],
v2:bat[:any_1]):bat[:bit] ", "CMDbatBETWEENsymmetric;", "B between V1 and
V2 (or vice versa) inclusive" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:bat[:any_1], v2:bat[:any_1],
s:bat[:oid]):bat[:bit] ", "CMDbatBETWEENsymmetric;", "B between V1 and
V2 (or vice versa) inclusive 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):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):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):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):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):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):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):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):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" ]
@@ -10062,8 +10054,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):bit ", "CMDvarBETWEEN;", "B between LO and HI inclusive" ]
-[ "calc", "between_symmetric", "pattern
calc.between_symmetric(b:any_1, v1:any_1, v2:any_1):bit ",
"CMDvarBETWEENsymmetric;", "B between V1 and V2 (or vice versa) inclusive"
]
+[ "calc", "between", "pattern calc.between(b:any_1, lo:any_1,
hi:any_1, sym:bit, linc:bit, hinc: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
@@ -8642,14 +8642,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],
lo:any_1, hi:any_1):bat[:bit] ", "CMDbatBETWEEN;", "B between LO
and HI inclusive" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:any_1, hi:any_1, s:bat[:oid]):bat[:bit] ", "CMDbatBETWEEN;", "B
between LO and HI inclusive with candidates list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:any_1, hi:bat[:any_1]):bat[:bit] ", "CMDbatBETWEEN;", "B between LO
and HI inclusive" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:any_1, hi:bat[:any_1], s:bat[:oid]):bat[:bit] ", "CMDbatBETWEEN;",
"B between LO and HI inclusive with candidates list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:bat[:any_1], hi:any_1):bat[:bit] ", "CMDbatBETWEEN;", "B between LO
and HI inclusive" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:bat[:any_1], hi:any_1, s:bat[:oid]):bat[:bit] ", "CMDbatBETWEEN;",
"B between LO and HI inclusive with candidates list" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:bat[:any_1], hi:bat[:any_1]):bat[:bit] ", "CMDbatBETWEEN;", "B
between LO and HI inclusive" ]
-[ "batcalc", "between", "pattern batcalc.between(b:bat[:any_1],
lo:bat[:any_1], hi:bat[:any_1], s:bat[:oid]):bat[:bit] ",
"CMDbatBETWEEN;", "B between LO and HI inclusive 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):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):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):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):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):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):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):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):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" ]
@@ -8658,14 +8658,6 @@ stdout of test 'MAL-signatures` in direc
[ "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_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:any_1, v2:any_1):bat[:bit] ",
"CMDbatBETWEENsymmetric;", "B between V1 and V2 (or vice versa) inclusive"
]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:any_1, v2:any_1,
s:bat[:oid]):bat[:bit] ", "CMDbatBETWEENsymmetric;", "B between V1 and V2
(or vice versa) inclusive with candidates list" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:any_1, v2:bat[:any_1]):bat[:bit] ",
"CMDbatBETWEENsymmetric;", "B between V1 and V2 (or vice versa)
inclusive" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:any_1, v2:bat[:any_1],
s:bat[:oid]):bat[:bit] ", "CMDbatBETWEENsymmetric;", "B between V1 and
V2 (or vice versa) inclusive with candidates list" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:bat[:any_1], v2:any_1):bat[:bit] ",
"CMDbatBETWEENsymmetric;", "B between V1 and V2 (or vice versa)
inclusive" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:bat[:any_1], v2:any_1,
s:bat[:oid]):bat[:bit] ", "CMDbatBETWEENsymmetric;", "B between V1 and
V2 (or vice versa) inclusive with candidates list" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:bat[:any_1],
v2:bat[:any_1]):bat[:bit] ", "CMDbatBETWEENsymmetric;", "B between V1 and
V2 (or vice versa) inclusive" ]
-[ "batcalc", "between_symmetric", "pattern
batcalc.between_symmetric(b:bat[:any_1], v1:bat[:any_1], v2:bat[:any_1],
s:bat[:oid]):bat[:bit] ", "CMDbatBETWEENsymmetric;", "B between V1 and
V2 (or vice versa) inclusive with candidates list" ]
[ "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" ]
@@ -14214,8 +14206,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):bit ", "CMDvarBETWEEN;", "B between LO and HI inclusive" ]
-[ "calc", "between_symmetric", "pattern
calc.between_symmetric(b:any_1, v1:any_1, v2:any_1):bit ",
"CMDvarBETWEENsymmetric;", "B between V1 and V2 (or vice versa) inclusive"
]
+[ "calc", "between", "pattern calc.between(b:any_1, lo:any_1,
hi:any_1, sym:bit, linc:bit, hinc: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 sym);
-BAT *BATcalcbetweenbatcst(BAT *b, BAT *lo, const ValRecord *hi, BAT *s, bool
sym);
-BAT *BATcalcbetweencstbat(BAT *b, const ValRecord *lo, BAT *hi, BAT *s, bool
sym);
-BAT *BATcalcbetweencstcst(BAT *b, const ValRecord *lo, const ValRecord *hi,
BAT *s, bool sym);
+BAT *BATcalcbetween(BAT *b, BAT *lo, BAT *hi, BAT *s, bool symmetric, bool
linc, bool hinc);
+BAT *BATcalcbetweenbatcst(BAT *b, BAT *lo, const ValRecord *hi, BAT *s, bool
symmetric, bool linc, bool hinc);
+BAT *BATcalcbetweencstbat(BAT *b, const ValRecord *lo, BAT *hi, BAT *s, bool
symmetric, bool linc, bool hinc);
+BAT *BATcalcbetweencstcst(BAT *b, const ValRecord *lo, const ValRecord *hi,
BAT *s, bool symmetric, bool linc, bool hinc);
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);
@@ -354,7 +354,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 sym);
+gdk_return VARcalcbetween(ValPtr ret, const ValRecord *v, const ValRecord *lo,
const ValRecord *hi, bool symmetric, bool linc, bool hinc);
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);
@@ -940,7 +940,6 @@ str CMDbatADDenlarge(Client cntxt, MalBl
str CMDbatADDsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
str CMDbatAND(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
str CMDbatBETWEEN(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
-str CMDbatBETWEENsymmetric(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr
pci);
str CMDbatCMP(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
str CMDbatDECR(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
str CMDbatDIV(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
@@ -1157,7 +1156,6 @@ str CMDvarADDstr(str *ret, str *s1, str
str CMDvarADDstrint(str *ret, str *s1, int *i);
str CMDvarAND(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
str CMDvarBETWEEN(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
-str CMDvarBETWEENsymmetric(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr
pci);
str CMDvarCMP(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
str CMDvarCONVERT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
str CMDvarCONVERTptr(ptr *ret, ptr *v);
@@ -2058,7 +2056,6 @@ str batstrRef;
str batxmlRef;
str bbpRef;
str betweenRef;
-str betweensymmetricRef;
str bindRef;
str binddbatRef;
str bindidxRef;
diff --git a/gdk/gdk_calc.c b/gdk/gdk_calc.c
--- a/gdk/gdk_calc.c
+++ b/gdk/gdk_calc.c
@@ -12760,8 +12760,11 @@ VARcalcrsh(ValPtr ret, const ValRecord *
#define BETWEEN(v, lo, hi, TYPE) \
(is_##TYPE##_nil(v) || is_##TYPE##_nil(lo) || is_##TYPE##_nil(hi) ? \
(nils++, bit_nil) : \
- (bit) (((v) >= (lo) && (v) <= (hi)) || \
- (sym && (v) >= (hi) && (v) <= (lo))))
+ (bit) ((((lo) < (v) || (linc && (lo) == (v))) && \
+ ((v) < (hi) || (hinc && (v) == (hi)))) || \
+ (symmetric &&
\
+ ((hi) < (v) || (hinc && (hi) == (v))) && \
+ ((v) < (lo) || (linc && (v) == (lo))))))
#define BETWEEN_LOOP_TYPE(TYPE)
\
do { \
@@ -12783,9 +12786,10 @@ static BAT *
BATcalcbetween_intern(const void *src, int incr1, const char *hp1, int wd1,
const void *lo, int incr2, const char *hp2, int wd2,
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 sym,
- const char *func)
+ int tp, BUN cnt, BUN start, BUN end,
+ const oid *restrict cand, const oid *candend,
+ oid seqbase, bool symmetric,
+ bool linc, bool hinc, const char *func)
{
BAT *bn;
BUN nils = 0;
@@ -12847,9 +12851,15 @@ BATcalcbetween_intern(const void *src, i
soff += wd1, loff += wd2, hoff += wd3) {
const void *p1, *p2, *p3;
CHECKCAND(dst, l, seqbase, bit_nil);
- p1 = hp1 ? (const void *) (hp1 + VarHeapVal(src, i,
wd1)) : (const void *) ((const char *) src + soff);
- p2 = hp2 ? (const void *) (hp2 + VarHeapVal(lo, j,
wd2)) : (const void *) ((const char *) lo + loff);
- p3 = hp3 ? (const void *) (hp3 + VarHeapVal(hi, k,
wd3)) : (const void *) ((const char *) hi + hoff);
+ p1 = hp1
+ ? (const void *) (hp1 + VarHeapVal(src, i, wd1))
+ : (const void *) ((const char *) src + soff);
+ p2 = hp2
+ ? (const void *) (hp2 + VarHeapVal(lo, j, wd2))
+ : (const void *) ((const char *) lo + loff);
+ p3 = hp3
+ ? (const void *) (hp3 + VarHeapVal(hi, k, wd3))
+ : (const void *) ((const char *) hi + hoff);
if (p1 == NULL || p2 == NULL || p3 == NULL ||
(*atomcmp)(p1, nil) == 0 ||
(*atomcmp)(p2, nil) == 0 ||
@@ -12857,11 +12867,17 @@ BATcalcbetween_intern(const void *src, i
nils++;
dst[l] = bit_nil;
} else {
- dst[l] = (bit) (((*atomcmp)(p1, p2) >= 0 &&
- (*atomcmp)(p1, p3) <= 0) ||
- (sym &&
- (*atomcmp)(p1, p3) >= 0 &&
- (*atomcmp)(p1, p2) <= 0));
+ 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))));
}
}
break;
@@ -12881,7 +12897,8 @@ BATcalcbetween_intern(const void *src, i
}
BAT *
-BATcalcbetween(BAT *b, BAT *lo, BAT *hi, BAT *s, bool sym)
+BATcalcbetween(BAT *b, BAT *lo, BAT *hi, BAT *s, bool symmetric,
+ bool linc, bool hinc)
{
BAT *bn;
BUN start, end, cnt;
@@ -12898,23 +12915,27 @@ BATcalcbetween(BAT *b, BAT *lo, BAT *hi,
CANDINIT(b, s, start, end, cnt, cand, candend);
- if (b->ttype == TYPE_void &&
- lo->ttype == TYPE_void &&
- hi->ttype == TYPE_void) {
+ if (BATtvoid(b) &&
+ BATtvoid(lo) &&
+ BATtvoid(hi)) {
bit res;
- if (is_oid_nil(b->tseqbase) ||
- is_oid_nil(lo->tseqbase) ||
- is_oid_nil(hi->tseqbase))
+ if (!BATtdense(b) || !BATtdense(lo) || !BATtdense(hi))
res = bit_nil;
else
- res = (bit) ((b->tseqbase >= lo->tseqbase &&
- b->tseqbase <= hi->tseqbase) ||
- (sym &&
- b->tseqbase >= hi->tseqbase &&
- b->tseqbase <= lo->tseqbase));
-
- return BATconstant(b->hseqbase, TYPE_bit, &res, BATcount(b),
TRANSIENT);
+ 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))));
+
+ return BATconstant(b->hseqbase, TYPE_bit, &res, BATcount(b),
+ TRANSIENT);
}
bn = BATcalcbetween_intern(Tloc(b, 0), 1,
@@ -12928,13 +12949,15 @@ BATcalcbetween(BAT *b, BAT *lo, BAT *hi,
hi->twidth,
b->ttype, cnt,
start, end, cand, candend,
- b->hseqbase, sym, "BATcalcbetween");
+ b->hseqbase, symmetric, linc, hinc,
+ "BATcalcbetween");
return bn;
}
BAT *
-BATcalcbetweencstcst(BAT *b, const ValRecord *lo, const ValRecord *hi, BAT *s,
bool sym)
+BATcalcbetweencstcst(BAT *b, const ValRecord *lo, const ValRecord *hi, BAT *s,
+ bool symmetric, bool linc, bool hinc)
{
BAT *bn;
BUN start, end, cnt;
@@ -12957,13 +12980,15 @@ BATcalcbetweencstcst(BAT *b, const ValRe
VALptr(hi), 0, NULL, 0,
b->ttype, cnt,
start, end, cand, candend,
- b->hseqbase, sym, "BATcalcbetweencstcst");
+ b->hseqbase, symmetric,
+ linc, hinc, "BATcalcbetweencstcst");
return bn;
}
BAT *
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
