Changeset: 8ab595855b90 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=8ab595855b90
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
gdk/gdk_calc_compare.h
monetdb5/modules/mal/00_batcalc_hge.mal
monetdb5/modules/mal/00_batcalc_hge.mal.sh
monetdb5/modules/mal/00_calc_hge.mal
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
Branch: default
Log Message:
Implemented an optional last argument nil_matches:bit for (bat)calc.{==,!=}.
The default for the argument is FALSE. If the value is TRUE, NIL is
considered a normal value which can match (i.e. result of the
operation is TRUE or FALSE). The old and the default case is that if
either side of the comparison is NIL, the result is also NIL.
diffs (truncated from 7430 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
@@ -678,257 +678,491 @@ Ready.
[ "batbam", "seq_char", "command batbam.seq_char(ref_pos:int,
alg_seq:bat[:str], alg_pos:bat[:int], alg_cigar:bat[:str]):bat[:str] ",
"seq_char_bat;", "Calculate the character in the alignment string
(alg_str) that is aligned to position 'ref_pos', conforming to the given cigar
string (bat based version)" ]
[ "batbam", "seq_length", "command
batbam.seq_length(cigars:bat[:str]):bat[:int] ", "seq_length_bat;",
"Calculate the real length of a bat of DNA sequences, given their CIGAR
string." ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bit],
b2:bat[:bit]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bit], b2:bat[:bit],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bit], b2:bat[:bit],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bit], b2:bat[:bit],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte],
b2:bat[:bte]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:bte],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:bte],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:bte],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte],
b2:bat[:dbl]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:dbl],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:dbl],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:dbl],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte],
b2:bat[:flt]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:flt],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:flt],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:flt],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte],
b2:bat[:int]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:int],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:int],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:int],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte],
b2:bat[:lng]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:lng],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:lng],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:lng],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte],
b2:bat[:sht]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:sht],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:sht],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:bte], b2:bat[:sht],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:date],
b2:bat[:date]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:date], b2:bat[:date],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with candidates
list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:daytime],
b2:bat[:daytime]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:daytime], b2:bat[:daytime],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl],
b2:bat[:bte]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:bte],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:bte],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:bte],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl],
b2:bat[:dbl]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:dbl],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:dbl],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:dbl],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl],
b2:bat[:flt]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:flt],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:flt],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:flt],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl],
b2:bat[:int]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:int],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:int],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:int],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl],
b2:bat[:lng]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:lng],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:lng],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:lng],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl],
b2:bat[:sht]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:sht],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:sht],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:dbl], b2:bat[:sht],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt],
b2:bat[:bte]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:bte],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:bte],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:bte],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt],
b2:bat[:dbl]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:dbl],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:dbl],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:dbl],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt],
b2:bat[:flt]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:flt],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:flt],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:flt],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt],
b2:bat[:int]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:int],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:int],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:int],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt],
b2:bat[:lng]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:lng],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:lng],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:lng],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt],
b2:bat[:sht]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:sht],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:sht],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:flt], b2:bat[:sht],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int],
b2:bat[:bte]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:bte],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:bte],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:bte],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int],
b2:bat[:dbl]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:dbl],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:dbl],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:dbl],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int],
b2:bat[:flt]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:flt],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:flt],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:flt],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int],
b2:bat[:int]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:int],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:int],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:int],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int],
b2:bat[:lng]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:lng],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:lng],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:lng],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int],
b2:bat[:sht]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:sht],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:sht],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:int], b2:bat[:sht],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:json],
b2:bat[:json]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng],
b2:bat[:bte]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:bte],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:bte],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:bte],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng],
b2:bat[:dbl]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:dbl],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:dbl],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:dbl],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng],
b2:bat[:flt]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:flt],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:flt],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:flt],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng],
b2:bat[:int]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:int],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:int],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:int],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng],
b2:bat[:lng]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:lng],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:lng],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:lng],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng],
b2:bat[:sht]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:sht],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:sht],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:lng], b2:bat[:sht],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:oid],
b2:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:oid], b2:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:oid], b2:bat[:oid],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:oid], b2:bat[:oid],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht],
b2:bat[:bte]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:bte],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:bte],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:bte],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht],
b2:bat[:dbl]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:dbl],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:dbl],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:dbl],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht],
b2:bat[:flt]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:flt],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:flt],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:flt],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht],
b2:bat[:int]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:int],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:int],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:int],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht],
b2:bat[:lng]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:lng],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:lng],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:lng],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht],
b2:bat[:sht]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:sht],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:sht],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:sht], b2:bat[:sht],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:str],
b2:bat[:str]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:str], b2:bat[:str],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:str], b2:bat[:str],
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2 with
candidates list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:str], b2:bat[:str],
s:bat[:oid], nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:timestamp],
b2:bat[:timestamp]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2"
]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:timestamp],
b2:bat[:timestamp], s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B1 !=
B2 with candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b1:bat[:uuid],
b2:bat[:uuid]):bat[:bit] ", "CMDbatNE;", "Return B1 != B2" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bit], v:bit):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bit], v:bit,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bit], v:bit,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bit], v:bit, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:bte):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:bte,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:bte,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:bte, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:dbl):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:dbl,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:dbl,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:dbl, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:flt):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:flt,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:flt,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:flt, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:int):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:int,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:int,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:int, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:lng):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:lng,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:lng,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:lng, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:sht):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:sht,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:sht,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:bte], v:sht, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:date], v:date):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:date], v:date,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:daytime],
v:daytime):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:daytime], v:daytime,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:bte):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:bte,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:bte,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:bte, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:dbl):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:dbl,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:dbl,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:dbl, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:flt):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:flt,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:flt,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:flt, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:int):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:int,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:int,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:int, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:lng):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:lng,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:lng,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:lng, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:sht):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:sht,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:sht,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:dbl], v:sht, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:bte):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:bte,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:bte,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:bte, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:dbl):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:dbl,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:dbl,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:dbl, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:flt):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:flt,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:flt,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:flt, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:int):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:int,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:int,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:int, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:lng):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:lng,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:lng,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:lng, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:sht):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:sht,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:sht,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:flt], v:sht, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:bte):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:bte,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:bte,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:bte, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:dbl):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:dbl,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:dbl,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:dbl, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:flt):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:flt,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:flt,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:flt, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:int):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:int,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:int,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:int, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:lng):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:lng,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:lng,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:lng, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:sht):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:sht,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:sht,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:int], v:sht, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:bte):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:bte,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:bte,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:bte, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:dbl):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:dbl,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:dbl,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:dbl, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:flt):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:flt,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:flt,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:flt, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:int):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:int,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:int,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:int, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:lng):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:lng,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:lng,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:lng, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:sht):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:sht,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:sht,
s:bat[:oid]):bat[:bit] ", "CMDbatNE;", "Return B != V with candidates
list" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:lng], v:sht, s:bat[:oid],
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V with
candidates list" ]
[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:oid], v:oid):bat[:bit] ",
"CMDbatNE;", "Return B != V" ]
+[ "batcalc", "!=", "pattern batcalc.!=(b:bat[:oid], v:oid,
nil_matches:bit):bat[:bit] ", "CMDbatNE;", "Return B != V" ]
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
