Changeset: db8d13d5f77d for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=db8d13d5f77d
Modified Files:
monetdb5/modules/mal/calc_arrays.c
monetdb5/modules/mal/calc_arrays.h
monetdb5/modules/mal/calc_arrays.mal
Branch: arrays
Log Message:
scalar multiplication
diffs (254 lines):
diff --git a/monetdb5/modules/mal/calc_arrays.c
b/monetdb5/modules/mal/calc_arrays.c
--- a/monetdb5/modules/mal/calc_arrays.c
+++ b/monetdb5/modules/mal/calc_arrays.c
@@ -2215,6 +2215,85 @@ str CMDdimensionMULsignal(Client cntxt,
return MAL_SUCCEED;
}
+str CMDscalarMULsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr
pci) {
+ BAT *s=NULL;
+
+ int resType;
+
+ /*get the arguments */
+ bat *result = getArgReference_bat(stk, pci, 0);
+ BAT *resBAT = NULL;
+
+ ptr *array_out = getArgReference(stk, pci, 1);
+ ptr *array_in = getArgReference(stk, pci, 4);
+
+ bat *vals = getArgReference_bat(stk, pci, 3);
+ BAT *valsBAT = BATdescriptor(*vals);
+ if(!valsBAT)
+ return createException(MAL, "calc.*", RUNTIME_OBJECT_MISSING);
+
+ /* get the types of the input and output arguments */
+ resType = getColumnType(getArgType(mb, pci, 0));
+// int valType = stk->stk[getArg(pci, 1)].vtype;
+// if (resType == TYPE_any)
+// resType = calctype(valType, BATttype(valsBAT));
+
+ resBAT = BATcalccstmul(&stk->stk[getArg(pci, 2)], valsBAT, s, resType, 1);
+
+ if (resBAT == NULL) {
+ BBPunfix(valsBAT->batCacheid);
+ return createException(MAL, "calc.*", OPERATION_FAILED);
+ }
+
+
+ (void) cntxt;
+ BBPunfix(valsBAT->batCacheid);
+ BBPkeepref(*result = resBAT->batCacheid);
+ *array_out = arrayCopy((gdk_array*)*array_in);
+
+ return MAL_SUCCEED;
+}
+
+
+str CMDscalarMULenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr
pci) {
+ BAT *s=NULL;
+
+ int resType;
+
+ /*get the arguments */
+ bat *result = getArgReference_bat(stk, pci, 0);
+ BAT *resBAT = NULL;
+
+ ptr *array_out = getArgReference(stk, pci, 1);
+ ptr *array_in = getArgReference(stk, pci, 4);
+
+ bat *vals = getArgReference_bat(stk, pci, 3);
+ BAT *valsBAT = BATdescriptor(*vals);
+ if(!valsBAT)
+ return createException(MAL, "calc.*", RUNTIME_OBJECT_MISSING);
+
+ /* get the types of the input and output arguments */
+ resType = getColumnType(getArgType(mb, pci, 0));
+// int valType = stk->stk[getArg(pci, 1)].vtype;
+// if (resType == TYPE_any)
+// resType = calctypeenlarge(valType, BATttype(valsBAT));
+
+ resBAT = BATcalccstmul(&stk->stk[getArg(pci, 2)], valsBAT, s, resType, 1);
+
+ if (resBAT == NULL) {
+ BBPunfix(valsBAT->batCacheid);
+ return createException(MAL, "calc.*", OPERATION_FAILED);
+ }
+
+
+ (void) cntxt;
+ BBPunfix(valsBAT->batCacheid);
+ BBPkeepref(*result = resBAT->batCacheid);
+ *array_out = arrayCopy((gdk_array*)*array_in);
+
+ return MAL_SUCCEED;
+}
+
#define checkEqual(TPE1, dimLeft, TPE2, dimRight, vals) \
do { \
BUN i=0; \
diff --git a/monetdb5/modules/mal/calc_arrays.h
b/monetdb5/modules/mal/calc_arrays.h
--- a/monetdb5/modules/mal/calc_arrays.h
+++ b/monetdb5/modules/mal/calc_arrays.h
@@ -15,6 +15,10 @@ str CMDdimensionCONVERT_oid(ptr *dimRes,
//str CMDdimensionCONVERT_str(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims);
str CMDdimensionMULsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr
pci);
+str CMDscalarMULsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr
pci);
+str CMDscalarMULenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr
pci);
+
+
str CMDdimensionsADDsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr
pci);
str CMDdimensionsEQ(ptr* dimsRes, bat* batRes, const ptr* dim1, const ptr*
dims1, const ptr* dim2, const ptr* dims2);
diff --git a/monetdb5/modules/mal/calc_arrays.mal
b/monetdb5/modules/mal/calc_arrays.mal
--- a/monetdb5/modules/mal/calc_arrays.mal
+++ b/monetdb5/modules/mal/calc_arrays.mal
@@ -72,8 +72,145 @@ comment "Return V * dimension values, gu
pattern calc.*(v:flt, dim:ptr, dims:ptr, tp:int) (:ptr, :ptr) address
CMDdimensionMULsignal
comment "Return V * dimension values, guarantee no overflow by returning
larger type";
-pattern calc.*(v:lng, vals:bat[:oid,:lng], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDnonDimensionMULsingnal_lng
-comment "Return a bat with the sum of the two dimensions";
+pattern calc.*(v:bte,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:sht], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:bte,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:int], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:bte,b:bat[:oid,:int], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:bte,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:sht,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:int], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:sht,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:int], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:sht,b:bat[:oid,:int], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:sht,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:int,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:int,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:int,b:bat[:oid,:int], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:int,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:lng,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:flt,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:flt,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:flt,b:bat[:oid,:int], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:flt,b:bat[:oid,:lng], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+pattern calc.*(v:flt,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULenlarge
+comment "Return V * B, guarantee no overflow by returning larger type";
+
+pattern calc.*(v:bte,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:bte], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:bte,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:sht], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:bte,b:bat[:oid,:int], array:ptr) (:bat[:oid,:int], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:bte,b:bat[:oid,:wrd], array:ptr) (:bat[:oid,:wrd], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:bte,b:bat[:oid,:lng], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:bte,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:bte,b:bat[:oid,:dbl], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:sht,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:sht], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:sht,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:sht], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:sht,b:bat[:oid,:int], array:ptr) (:bat[:oid,:int], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:sht,b:bat[:oid,:wrd], array:ptr) (:bat[:oid,:wrd], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:sht,b:bat[:oid,:lng], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:sht,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:sht,b:bat[:oid,:dbl], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:int,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:int], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:int,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:int], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:int,b:bat[:oid,:int], array:ptr) (:bat[:oid,:int], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:int,b:bat[:oid,:wrd], array:ptr) (:bat[:oid,:wrd], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:int,b:bat[:oid,:lng], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:int,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:int,b:bat[:oid,:dbl], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:wrd,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:wrd], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:wrd,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:wrd], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:wrd,b:bat[:oid,:int], array:ptr) (:bat[:oid,:wrd], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:wrd,b:bat[:oid,:wrd], array:ptr) (:bat[:oid,:wrd], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:wrd,b:bat[:oid,:lng], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:wrd,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:wrd,b:bat[:oid,:dbl], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:lng,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:lng,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:lng,b:bat[:oid,:int], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:lng,b:bat[:oid,:wrd], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:lng,b:bat[:oid,:lng], array:ptr) (:bat[:oid,:lng], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:lng,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:lng,b:bat[:oid,:dbl], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:flt,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:flt,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:flt,b:bat[:oid,:int], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:flt,b:bat[:oid,:wrd], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:flt,b:bat[:oid,:lng], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:flt,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:flt], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:flt,b:bat[:oid,:dbl], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:dbl,b:bat[:oid,:bte], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:dbl,b:bat[:oid,:sht], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:dbl,b:bat[:oid,:int], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:dbl,b:bat[:oid,:wrd], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:dbl,b:bat[:oid,:lng], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:dbl,b:bat[:oid,:flt], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+pattern calc.*(v:dbl,b:bat[:oid,:dbl], array:ptr) (:bat[:oid,:dbl], :ptr)
address CMDscalarMULsignal
+comment "Return V * B, signal error on overflow";
+
+
+
+
##/
#pattern /(dim:ptr, dims:ptr, v:bte) (:ptr, :ptr) address CMDdimensionDIVsignal
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
