Changeset: f0f4f270fd1b for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=f0f4f270fd1b
Modified Files:
        monetdb5/modules/kernel/batcalc.mal
        monetdb5/modules/kernel/batcalc.mal.sh
Branch: Jul2012
Log Message:

Use the correct batcalc implementation function.


diffs (truncated from 501 to 300 lines):

diff --git a/monetdb5/modules/kernel/batcalc.mal 
b/monetdb5/modules/kernel/batcalc.mal
--- a/monetdb5/modules/kernel/batcalc.mal
+++ b/monetdb5/modules/kernel/batcalc.mal
@@ -368,7 +368,7 @@ pattern +(b:bat[:oid,:bte],v:bte) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:bte,b:bat[:oid,:bte]) :bat[:oid,:sht]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:bte],b2:bat[:oid,:sht]) :bat[:oid,:int]
@@ -378,7 +378,7 @@ pattern +(b:bat[:oid,:bte],v:sht) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:bte,b:bat[:oid,:sht]) :bat[:oid,:int]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:bte],b2:bat[:oid,:int]) :bat[:oid,:lng]
@@ -388,7 +388,7 @@ pattern +(b:bat[:oid,:bte],v:int) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:bte,b:bat[:oid,:int]) :bat[:oid,:lng]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:bte],b2:bat[:oid,:flt]) :bat[:oid,:dbl]
@@ -398,7 +398,7 @@ pattern +(b:bat[:oid,:bte],v:flt) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:bte,b:bat[:oid,:flt]) :bat[:oid,:dbl]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:sht],b2:bat[:oid,:bte]) :bat[:oid,:int]
@@ -408,7 +408,7 @@ pattern +(b:bat[:oid,:sht],v:bte) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:sht,b:bat[:oid,:bte]) :bat[:oid,:int]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:sht],b2:bat[:oid,:sht]) :bat[:oid,:int]
@@ -418,7 +418,7 @@ pattern +(b:bat[:oid,:sht],v:sht) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:sht,b:bat[:oid,:sht]) :bat[:oid,:int]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:sht],b2:bat[:oid,:int]) :bat[:oid,:lng]
@@ -428,7 +428,7 @@ pattern +(b:bat[:oid,:sht],v:int) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:sht,b:bat[:oid,:int]) :bat[:oid,:lng]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:sht],b2:bat[:oid,:flt]) :bat[:oid,:dbl]
@@ -438,7 +438,7 @@ pattern +(b:bat[:oid,:sht],v:flt) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:sht,b:bat[:oid,:flt]) :bat[:oid,:dbl]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:int],b2:bat[:oid,:bte]) :bat[:oid,:lng]
@@ -448,7 +448,7 @@ pattern +(b:bat[:oid,:int],v:bte) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:int,b:bat[:oid,:bte]) :bat[:oid,:lng]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:int],b2:bat[:oid,:sht]) :bat[:oid,:lng]
@@ -458,7 +458,7 @@ pattern +(b:bat[:oid,:int],v:sht) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:int,b:bat[:oid,:sht]) :bat[:oid,:lng]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:int],b2:bat[:oid,:int]) :bat[:oid,:lng]
@@ -468,7 +468,7 @@ pattern +(b:bat[:oid,:int],v:int) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:int,b:bat[:oid,:int]) :bat[:oid,:lng]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:int],b2:bat[:oid,:flt]) :bat[:oid,:dbl]
@@ -478,7 +478,7 @@ pattern +(b:bat[:oid,:int],v:flt) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:int,b:bat[:oid,:flt]) :bat[:oid,:dbl]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:lng],b2:bat[:oid,:flt]) :bat[:oid,:dbl]
@@ -488,7 +488,7 @@ pattern +(b:bat[:oid,:lng],v:flt) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:lng,b:bat[:oid,:flt]) :bat[:oid,:dbl]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:flt],b2:bat[:oid,:bte]) :bat[:oid,:dbl]
@@ -498,7 +498,7 @@ pattern +(b:bat[:oid,:flt],v:bte) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:flt,b:bat[:oid,:bte]) :bat[:oid,:dbl]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:flt],b2:bat[:oid,:sht]) :bat[:oid,:dbl]
@@ -508,7 +508,7 @@ pattern +(b:bat[:oid,:flt],v:sht) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:flt,b:bat[:oid,:sht]) :bat[:oid,:dbl]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:flt],b2:bat[:oid,:int]) :bat[:oid,:dbl]
@@ -518,7 +518,7 @@ pattern +(b:bat[:oid,:flt],v:int) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:flt,b:bat[:oid,:int]) :bat[:oid,:dbl]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:flt],b2:bat[:oid,:lng]) :bat[:oid,:dbl]
@@ -528,7 +528,7 @@ pattern +(b:bat[:oid,:flt],v:lng) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:flt,b:bat[:oid,:lng]) :bat[:oid,:dbl]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 command +(b1:bat[:oid,:flt],b2:bat[:oid,:flt]) :bat[:oid,:dbl]
@@ -538,7 +538,7 @@ pattern +(b:bat[:oid,:flt],v:flt) :bat[:
 address CMDbatADDcstenlarge
 comment "Return B + V, guarantee no overflow by returning larger type";
 pattern +(v:flt,b:bat[:oid,:flt]) :bat[:oid,:dbl]
-address CMDbatADDcstsignal
+address CMDbatADDcstenlarge
 comment "Return V + B, guarantee no overflow by returning larger type";
 
 
@@ -549,7 +549,7 @@ pattern -(b:bat[:oid,:bte],v:bte) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:bte,b:bat[:oid,:bte]) :bat[:oid,:sht]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:bte],b2:bat[:oid,:sht]) :bat[:oid,:int]
@@ -559,7 +559,7 @@ pattern -(b:bat[:oid,:bte],v:sht) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:bte,b:bat[:oid,:sht]) :bat[:oid,:int]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:bte],b2:bat[:oid,:int]) :bat[:oid,:lng]
@@ -569,7 +569,7 @@ pattern -(b:bat[:oid,:bte],v:int) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:bte,b:bat[:oid,:int]) :bat[:oid,:lng]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:bte],b2:bat[:oid,:flt]) :bat[:oid,:dbl]
@@ -579,7 +579,7 @@ pattern -(b:bat[:oid,:bte],v:flt) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:bte,b:bat[:oid,:flt]) :bat[:oid,:dbl]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:sht],b2:bat[:oid,:bte]) :bat[:oid,:int]
@@ -589,7 +589,7 @@ pattern -(b:bat[:oid,:sht],v:bte) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:sht,b:bat[:oid,:bte]) :bat[:oid,:int]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:sht],b2:bat[:oid,:sht]) :bat[:oid,:int]
@@ -599,7 +599,7 @@ pattern -(b:bat[:oid,:sht],v:sht) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:sht,b:bat[:oid,:sht]) :bat[:oid,:int]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:sht],b2:bat[:oid,:int]) :bat[:oid,:lng]
@@ -609,7 +609,7 @@ pattern -(b:bat[:oid,:sht],v:int) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:sht,b:bat[:oid,:int]) :bat[:oid,:lng]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:sht],b2:bat[:oid,:flt]) :bat[:oid,:dbl]
@@ -619,7 +619,7 @@ pattern -(b:bat[:oid,:sht],v:flt) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:sht,b:bat[:oid,:flt]) :bat[:oid,:dbl]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:int],b2:bat[:oid,:bte]) :bat[:oid,:lng]
@@ -629,7 +629,7 @@ pattern -(b:bat[:oid,:int],v:bte) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:int,b:bat[:oid,:bte]) :bat[:oid,:lng]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:int],b2:bat[:oid,:sht]) :bat[:oid,:lng]
@@ -639,7 +639,7 @@ pattern -(b:bat[:oid,:int],v:sht) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:int,b:bat[:oid,:sht]) :bat[:oid,:lng]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:int],b2:bat[:oid,:int]) :bat[:oid,:lng]
@@ -649,7 +649,7 @@ pattern -(b:bat[:oid,:int],v:int) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:int,b:bat[:oid,:int]) :bat[:oid,:lng]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:int],b2:bat[:oid,:flt]) :bat[:oid,:dbl]
@@ -659,7 +659,7 @@ pattern -(b:bat[:oid,:int],v:flt) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:int,b:bat[:oid,:flt]) :bat[:oid,:dbl]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:lng],b2:bat[:oid,:flt]) :bat[:oid,:dbl]
@@ -669,7 +669,7 @@ pattern -(b:bat[:oid,:lng],v:flt) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:lng,b:bat[:oid,:flt]) :bat[:oid,:dbl]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:flt],b2:bat[:oid,:bte]) :bat[:oid,:dbl]
@@ -679,7 +679,7 @@ pattern -(b:bat[:oid,:flt],v:bte) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:flt,b:bat[:oid,:bte]) :bat[:oid,:dbl]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:flt],b2:bat[:oid,:sht]) :bat[:oid,:dbl]
@@ -689,7 +689,7 @@ pattern -(b:bat[:oid,:flt],v:sht) :bat[:
 address CMDbatSUBcstenlarge
 comment "Return B - V, guarantee no overflow by returning larger type";
 pattern -(v:flt,b:bat[:oid,:sht]) :bat[:oid,:dbl]
-address CMDbatSUBcstsignal
+address CMDbatSUBcstenlarge
 comment "Return V - B, guarantee no overflow by returning larger type";
 
 command -(b1:bat[:oid,:flt],b2:bat[:oid,:int]) :bat[:oid,:dbl]
_______________________________________________
Checkin-list mailing list
Checkin-list@monetdb.org
http://mail.monetdb.org/mailman/listinfo/checkin-list

Reply via email to