* Bug #13515 fixed - There were wrong results for matrix/hypermatrix with bitset... 81/14981/2
Vladislav TRUBKIN [Tue, 5 Aug 2014 15:21:20 +0000 (17:21 +0200)]
Change-Id: I7f90b84eb328407f9b4defcd8a1d970265734719

scilab/CHANGES_5.5.X
scilab/modules/elementary_functions/macros/bitset.sci
scilab/modules/elementary_functions/tests/nonreg_tests/bug_13515.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/nonreg_tests/bug_13515.tst [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/bitset.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/bitset.tst

index 7705237..90e5eab 100644 (file)
@@ -182,6 +182,8 @@ Scilab Bug Fixes
 
 * Bug #13512 fixed - dae crashed if the evaluation function had wrong prototype.
 
+* Bug #13515 fixed - There were wrong results for matrix/hypermatrix with bitset function.
+
 
 Xcos Bug Fixes
 ==============
index f6dd1a2..182d9ab 100644 (file)
@@ -26,7 +26,6 @@ function y = bitset(x,pos,v)
     end
 
     // case empty matrix
-
     if isempty(x)
         if ~isempty(pos) & prod(size(pos))<>1
             error(msprintf(gettext("%s: Wrong size for input arguments: Same sizes expected.\n"),"bitset"));
@@ -36,50 +35,45 @@ function y = bitset(x,pos,v)
         end
     end
 
-    // check size
+    // check v value
+    if rhs == 3 & or(v <> 0 & v <> 1) then
+        error(msprintf(gettext("%s: Wrong value for input argument #%d: 0 or 1 expected.\n"),"bitset",3));
+    elseif rhs == 2 then
+        v = ones(x);
+    end
 
-    if (size(x,"*")>1) & (size(pos,"*")>1) & (or(size(x)<>size(pos))) then
+    // check size
+    if or(size(x) <> size(pos)) | or(size(v) <> size(x)) then
         error(msprintf(gettext("%s: Wrong size for input arguments: Same sizes expected.\n"),"bitset"));
     end
 
     // check type
-
-    if    (type(x)==1  & (x-floor(x)<>0 | x<0)) ..
-        | (type(x)==8  & (inttype(x)<10)) ..
-        | (type(x)<>1  & type(x)<>8) then
-
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: Scalar/matrix of unsigned integers expected.\n"),"bitset",1));
+    if (type(x) == 1  & (or(x-floor(x) <> 0) | or(x < 0))) ..
+        | (type(x) == 8  & (inttype(x) < 10)) ..
+        | (typeof(x) == "hypermat" & (or(x-floor(x) <> 0) | or(x < 0))) ..
+        | (type(x) <> 1 & type(x) <> 8 & typeof(x) <> "hypermat") then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Scalar/matrix/hypermatrix of unsigned integers expected.\n"),"bitset",1));
     end
 
-    if    (type(pos)==1  & (pos-floor(pos)<>0 | pos<0)) ..
-        | (type(pos)==8  & (inttype(pos)<10)) ..
-        | (type(pos)<>1  & type(pos)<>8) then
-
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: Scalar/matrix of unsigned integers expected.\n"),"bitset",2));
+    if (type(pos) == 1  & (or(pos-floor(pos) <> 0) | or(pos < 0))) ..
+        | (type(pos) == 8  & (inttype(pos) < 10)) ..
+        | (typeof(pos) == "hypermat" & (or(pos-floor(pos) <> 0) | or(pos < 0))) ..
+        | (type(pos) <> 1 & type(pos) <> 8 & typeof(pos) <> "hypermat") then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Scalar/matrix/hypermatrix of unsigned integers expected.\n"),"bitset",2));
     end
 
     // check pos value
-
-    select inttype(x)
+    select inttype(x(1))
     case 0  then posmax = 52;
     case 11 then posmax = 8;
     case 12 then posmax = 16;
     case 14 then posmax = 32;
     end
 
-    if (pos>posmax) | (pos<1) then
+    if or(pos > posmax) | or(pos < 1) then
         error(msprintf(gettext("%s: Wrong value for input argument #%d: Must be between %d and %d.\n"),"bitset",2,1,posmax));
     end
 
-    // check v value
-
-    if rhs == 3 & ..
-        ( ((type(v)<>1) & (type(v)<>8)) ..
-        | ((type(x)==8) & (inttype(x)<10)) ..
-        | ((v<>0) & (v<>1)) ) then
-        error(msprintf(gettext("%s: Wrong value for input argument #%d: 0 or 1 expected\n"),"bitset",3));
-    end
-
     // Algorithm
     // =========================================================================
 
@@ -91,30 +85,27 @@ function y = bitset(x,pos,v)
         x    = ones(pos)*x;
     end
 
-    if rhs<3 then
-        v = 1;
-    end
+    vZero = find(v == 0);
+    vOne = find(v == 1);
+    sz = size(x);
 
-    if type(x)==8 then
+    if type(x(1)) == 8 then
 
-        select inttype(x)
-        case 11 then mask = uint8(2^(pos-1));
-        case 12 then mask = uint16(2^(pos-1));
-        case 14 then mask = uint32(2^(pos-1));
+        select inttype(x(1))
+        case 11 then mask = uint8(2^(pos(:)-1));
+        case 12 then mask = uint16(2^(pos(:)-1));
+        case 14 then mask = uint32(2^(pos(:)-1));
         end
 
-        if v==0 then
-            y = x & (~mask);
-        else
-            y = x | mask;
-        end
+        mask = matrix(mask, sz);
+        y(vZero) = x(vZero) & (~mask(vZero));
+        y(vOne) = x(vOne) | mask(vOne);
+        y = matrix(y, sz);
 
         return;
 
     else
-
         // type == 1
-
         a     = 2^32;
         mask  = uint32(zeros(pos));
 
@@ -123,27 +114,33 @@ function y = bitset(x,pos,v)
 
         y_LSB = uint32( x - double(uint32(x/a)) * a ); // LSB Less Significant Bits
         y_MSB = uint32( x/a );                         // MSB Most Significant Bits
+        yMSB  = y_MSB;
+        yLSB  = y_LSB;
 
         if or(pos<=32) then
-            mask(  pos<=32 ) = uint32( 2^(pos(pos<=32) -1 ));
-            if v==0 then
-                y_LSB( pos<=32 ) = y_LSB(pos<=32) & (~mask(pos<=32));
-            else
-                y_LSB( pos<=32 ) = y_LSB(pos<=32) | mask(pos<=32);
-            end
+            mask(pos<=32) = uint32(2^(pos(pos<=32) -1));
+            yLSB = y_LSB(pos<=32);
+            ymask = mask(pos<=32);
+            // v == 0
+            yLSB(vZero) = yLSB(vZero) & (~ymask(vZero));
+            // v == 1
+            yLSB(vOne) = yLSB(vOne) | ymask(vOne);
+            yLSB = matrix(yLSB, sz);
         end
 
         if or(pos>32) then
-            mask(  pos>32 ) = uint32( 2^(pos(pos>32) -32 -1 ));
-            if v==0 then
-                y_MSB( pos>32 ) = y_MSB(pos>32) & (~ mask(pos>32));
-            else
-                y_MSB( pos>32 ) = y_MSB(pos>32) | mask(pos>32);
-            end
+            mask(pos>32) = uint32(2^(pos(pos>32) -32 -1));
+            yMSB = y_MSB(pos>32);
+            ymask = mask(pos>32);
+            yMSB(vZero) = yMSB(vZero) & (~ymask(vZero));
+            yMSB(vOne) = yMSB(vOne) | ymask(vOne);
+            // v == 0
+            yMSB(vZero) = yMSB(vZero) & (~ymask(vZero));
+            // v == 1
+            yMSB(vOne) = yMSB(vOne) | ymask(vOne);
+            yMSB = matrix(yMSB, sz);
         end
-
-        y = double( a * y_MSB + y_LSB );
-
+        y = double(a * yMSB + yLSB);
     end
 
 endfunction
diff --git a/scilab/modules/elementary_functions/tests/nonreg_tests/bug_13515.dia.ref b/scilab/modules/elementary_functions/tests/nonreg_tests/bug_13515.dia.ref
new file mode 100644 (file)
index 0000000..f50aa5e
--- /dev/null
@@ -0,0 +1,278 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2014 - Scilab Enterprises - Vladislav TRUBKIN
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- Non-regression test for bug 13515 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/13515
+//
+// <-- Short Description -->
+// there were wrong results for matrix/hypermatrix with bitset function
+//
+clear "checkBitset"
+function checkBitset(x, pos, v, isOne, typeOfx)
+    if isOne then
+        select typeOfx
+            case 0 // double
+                assert_checkequal(bitset(x, pos), dbRefOne);
+                assert_checkequal(bitset(x, pos, v), dbRefOne);
+            case 8 // uint8
+                assert_checkequal(bitset(x, pos), uint8RefOne);
+                assert_checkequal(bitset(x, pos, v), uint8RefOne);
+            case 16 // uint16
+                assert_checkequal(bitset(x, pos), uint16RefOne);
+                assert_checkequal(bitset(x, pos, v), uint16RefOne);
+            case 32 // uint32
+                assert_checkequal(bitset(x, pos), uint32RefOne);
+                assert_checkequal(bitset(x, pos, v), uint32RefOne);
+        end
+    else
+         select typeOfx
+            case 0
+                assert_checkequal(bitset(x, pos, v), dbRefZero);
+            case 8
+                assert_checkequal(bitset(x, pos, v), uint8RefZero);
+            case 16
+                assert_checkequal(bitset(x, pos, v), uint16RefZero);
+            case 32
+                assert_checkequal(bitset(x, pos, v), uint32RefZero);
+        end
+    end
+endfunction
+clear "createValues"
+function [dbValue, dbPos, dbBitValue, ...
+          uint8Value, uint8Pos, uint8BitValue, ...
+          uint16Value, uint16Pos, uint16BitValue, ...
+          uint32Value, uint32Pos, uint32BitValue] = createValues(value, pos, bitValue)
+            // double
+            dbValue = value;
+            dbPos = pos;
+            dbBitValue = bitValue
+            // uint8
+            uint8Value = uint8(value);
+            uint8Pos = uint8(pos);
+            uint8BitValue = uint8(bitValue);
+            // uint16 
+            uint16Value = uint16(value);
+            uint16Pos = uint16(pos);
+            uint16BitValue = uint16(bitValue);
+            // uint32
+            uint32Value = uint32(value);
+            uint32Pos = uint32(pos);
+            uint32BitValue = uint32(bitValue);
+endfunction
+clear "createReference";
+function [dbRefOne, dbRefZero, ...
+          uint8RefOne, uint8RefZero, ...
+          uint16RefOne, uint16RefZero, ...
+          uint32RefOne, uint32RefZero] = createReference(refOne, refZero)
+            dbRefOne = refOne;
+            dbRefZero = refZero;
+            uint8RefOne = uint8(dbRefOne);
+            uint16RefOne = uint16(dbRefOne);
+            uint32RefOne = uint32(dbRefOne);
+            uint8RefZero = uint8(dbRefZero);
+            uint16RefZero = uint16(dbRefZero);
+            uint32RefZero = uint32(dbRefZero);
+endfunction
+// check input arguments
+lstr = gettext("%s: Wrong number of input argument(s): At least %d expected.\n");
+errmsg = msprintf (lstr, "bitset", 2);
+assert_checkerror("bitset(1)", errmsg);
+assert_checkerror("bitset()", errmsg);
+lstr = gettext("%s: Wrong size for input arguments: Same sizes expected.\n");
+errmsg = msprintf (lstr, "bitset");
+assert_checkerror("bitset([], [1, 2])", errmsg);
+lstr = gettext("%s: Wrong value for input argument #%d: 0 or 1 expected.\n");
+errmsg = msprintf (lstr, "bitset", 3);
+assert_checkerror("bitset(1, 1, 3)", errmsg);
+assert_checkerror("bitset(1, 1, %t)", errmsg);
+assert_checkerror("bitset([1, 2], [1, 1], [2, 0])", errmsg);
+assert_checkerror("bitset([1; 2; 3], [1; 1; 1], [0; 0; 4])", errmsg);
+lstr = gettext("%s: Wrong size for input arguments: Same sizes expected.\n");
+errmsg = msprintf (lstr, "bitset");
+assert_checkerror("bitset(1, [1, 2], 1)", errmsg);
+assert_checkerror("bitset([1, 2], [1, 2, 3], 1)", errmsg);
+assert_checkerror("bitset([1, 2, 3], [1, 2, 3], 1)", errmsg);
+lstr = gettext("%s: Wrong type for input argument #%d: Scalar/matrix/hypermatrix of unsigned integers expected.\n");
+errmsg = msprintf (lstr, "bitset", 1);
+assert_checkerror("bitset(""1"", 1, 1)", errmsg);
+assert_checkerror("bitset(poly(0,""s""), 1, 1)", errmsg);
+assert_checkerror("bitset([1, -1], [1, 0], [1, 0])", errmsg);
+assert_checkerror("bitset([0.5, 0.2], [1, 0], [1, 0])", errmsg);
+assert_checkerror("bitset([%t, %t], [1, 0], [1, 0])", errmsg);
+assert_checkerror("bitset(int32([1, 1]), [1, 0], [1, 0])", errmsg);
+assert_checkerror("bitset(int16([1, 1]), [1, 0], [1, 0])", errmsg);
+assert_checkerror("bitset(int8([1, 1]), [1, 0], [1, 0])", errmsg);
+errmsg = msprintf (lstr, "bitset", 2);
+assert_checkerror("bitset(1,""1"", 1)", errmsg);
+assert_checkerror("bitset(1, poly(0,""s""), 1)", errmsg);
+assert_checkerror("bitset([1, 0], [1, -1], [1, 0])", errmsg);
+assert_checkerror("bitset([1, 0], [0.5, 0.2], [1, 0])", errmsg);
+assert_checkerror("bitset([1; 0], [%t; %t], [1; 0])", errmsg);
+assert_checkerror("bitset([1, 0], int32([1, 1]), [1, 0])", errmsg);
+assert_checkerror("bitset([1, 0], int16([1, 1]), [1, 0])", errmsg);
+assert_checkerror("bitset([1, 0], int8([1, 1]), [1, 0])", errmsg);
+lstr = gettext("%s: Wrong value for input argument #%d: Must be between %d and %d.\n");
+errmsg = msprintf (lstr, "bitset", 2, 1, 52);
+assert_checkerror("bitset([1, 0], [1, 53], [1, 0])", errmsg);
+assert_checkerror("bitset([1, 0], [0, 5], [1, 0])", errmsg);
+errmsg = msprintf (lstr, "bitset", 2, 1, 8);
+assert_checkerror("bitset(uint8([1, 0; 1, 0]), [1, 2; 1, 9], [1, 0; 1, 1])", errmsg);
+assert_checkerror("bitset(uint8([1, 0; 1, 0]), [1, 0; 0, 1], [1, 0; 1, 1])", errmsg);
+errmsg = msprintf (lstr, "bitset", 2, 1, 16);
+assert_checkerror("bitset(uint16([1, 0; 1, 0]), [1, 17; 1, 9], [1, 0; 1, 1])", errmsg);
+assert_checkerror("bitset(uint16([1, 0; 1, 0]), [1, 0; 0, 1], [1, 0; 1, 1])", errmsg);
+errmsg = msprintf (lstr, "bitset", 2, 1, 32);
+assert_checkerror("bitset(uint32([1, 0; 1, 0]), [1, 17; 33, 1], [1, 0; 1, 1])", errmsg);
+assert_checkerror("bitset(uint32([1, 0; 1, 0]), [1, 1; 0, 1], [1, 0; 1, 1])", errmsg);
+// check results
+// create value to check
+value = [9, 10, 11, 12, 13, 14, 15];
+position = [2, 3, 4, 5, 6, 7, 8];
+bitValue = zeros(1:7);
+[dbValue, dbPos, dbBitValue, ...
+ uint8Value, uint8Pos, uint8BitValue, ...
+ uint16Value, uint16Pos, uint16BitValue, ...
+ uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
+// create references
+refOne = [11, 14, 11, 28, 45, 78, 143];
+refZero = [9, 10, 3, 12, 13, 14, 15];
+[dbRefOne, dbRefZero, ...
+ uint8RefOne, uint8RefZero, ...
+ uint16RefOne, uint16RefZero, ...
+ uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
+// check only the same types
+// only double
+checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
+// only uint8
+checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
+checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
+// only uint16
+checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
+checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
+// only uint32
+checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
+checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
+// check mixte types
+// double
+checkBitset(dbValue, uint8Pos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, uint8Pos, dbBitValue, %f, 0);
+checkBitset(dbValue, uint8Pos, uint8BitValue, %f, 0);
+checkBitset(dbValue, uint16Pos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, uint16Pos, dbBitValue, %f, 0);
+checkBitset(dbValue, uint16Pos, uint8BitValue, %f, 0);
+checkBitset(dbValue, uint32Pos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, uint32Pos, dbBitValue, %f, 0);
+// uint8
+checkBitset(uint8Value, dbPos, dbBitValue + 1, %t, 8);
+checkBitset(uint8Value, dbPos, dbBitValue, %f, 8);
+checkBitset(uint8Value, uint16Pos, uint16BitValue + 1, %t, 8);
+checkBitset(uint8Value, uint16Pos, dbBitValue, %f, 8);
+checkBitset(uint8Value, uint32Pos, uint8BitValue, %f, 8);
+checkBitset(uint8Value, uint32Pos, dbBitValue + 1, %t, 8);
+// uint16
+checkBitset(uint16Value, dbPos, dbBitValue + 1, %t, 16);
+checkBitset(uint16Value, dbPos, dbBitValue, %f, 16);
+checkBitset(uint16Value, uint8Pos, uint16BitValue + 1, %t, 16);
+checkBitset(uint16Value, uint8Pos, dbBitValue, %f, 16);
+checkBitset(uint16Value, uint32Pos, uint8BitValue, %f, 16);
+checkBitset(uint16Value, uint32Pos, dbBitValue + 1, %t, 16);
+// uint32
+checkBitset(uint32Value, dbPos, uint32BitValue + 1, %t, 32);
+checkBitset(uint32Value, dbPos, uint32BitValue, %f, 32);
+checkBitset(uint32Value, uint16Pos, uint16BitValue + 1, %t, 32);
+checkBitset(uint32Value, uint16Pos, dbBitValue, %f, 32);
+checkBitset(uint32Value, uint8Pos, uint8BitValue, %f, 32);
+checkBitset(uint32Value, uint8Pos, dbBitValue + 1, %t, 32);
+// create value to check
+value = [4; 5; 6];
+position = [1; 2; 3];
+bitValue = zeros(1:3)';
+[dbValue, dbPos, dbBitValue, ...
+ uint8Value, uint8Pos, uint8BitValue, ...
+ uint16Value, uint16Pos, uint16BitValue, ...
+ uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
+// create references
+refOne = [5; 7; 6];
+refZero = [4; 5; 2];
+[dbRefOne, dbRefZero, ...
+ uint8RefOne, uint8RefZero, ...
+ uint16RefOne, uint16RefZero, ...
+ uint32RefOne, uint32RefZero] = createReference(refOne, refZero); 
+// check values
+// double
+checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
+// uint8
+checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
+checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
+// uint16
+checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
+checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
+// uint32
+checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
+checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
+// create value to check
+value = [1, 2, 3; 4, 5, 6];
+position = [2, 2, 2; 3, 3, 3];
+bitValue = zeros(2, 3);
+[dbValue, dbPos, dbBitValue, ...
+ uint8Value, uint8Pos, uint8BitValue, ...
+ uint16Value, uint16Pos, uint16BitValue, ...
+ uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
+// create references
+refOne = [3, 2, 3; 4, 5, 6];
+refZero = [1, 0, 1; 0, 1, 2];
+[dbRefOne, dbRefZero, ...
+ uint8RefOne, uint8RefZero, ...
+ uint16RefOne, uint16RefZero, ...
+ uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
+// check values
+// double
+checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
+// uint8
+checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
+checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
+// uint16
+checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
+checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
+// uint32
+checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
+checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
+// create value to check
+value = hypermat([2 3 1 2], 1:12);
+position = ones(value)*3;
+position(1:6) = 4;
+bitValue = hypermat(size(value), zeros(1:12));
+[dbValue, dbPos, dbBitValue, ...
+ uint8Value, uint8Pos, uint8BitValue, ...
+ uint16Value, uint16Pos, uint16BitValue, ...
+ uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
+// create references
+refOne = [9, 10, 11, 12, 13, 14, 7, 12, 13, 14, 15, 12];
+refZero = [1, 2, 3, 4, 5, 6, 3, 8, 9, 10, 11, 8];
+refOne = hypermat([2 3 1 2], refOne);
+refZero = hypermat([2 3 1 2], refZero);
+[dbRefOne, dbRefZero, ...
+ uint8RefOne, uint8RefZero, ...
+ uint16RefOne, uint16RefZero, ...
+ uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
+// check values
+// double
+checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
+// uint8
+checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
+checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
+// uint16
+checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
+checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
+// uint32
+checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
+checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
diff --git a/scilab/modules/elementary_functions/tests/nonreg_tests/bug_13515.tst b/scilab/modules/elementary_functions/tests/nonreg_tests/bug_13515.tst
new file mode 100644 (file)
index 0000000..1d211d2
--- /dev/null
@@ -0,0 +1,297 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2014 - Scilab Enterprises - Vladislav TRUBKIN
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- Non-regression test for bug 13515 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/13515
+//
+// <-- Short Description -->
+// there were wrong results for matrix/hypermatrix with bitset function
+//
+
+clear "checkBitset"
+function checkBitset(x, pos, v, isOne, typeOfx)
+    if isOne then
+        select typeOfx
+        case 0 // double
+            assert_checkequal(bitset(x, pos), dbRefOne);
+            assert_checkequal(bitset(x, pos, v), dbRefOne);
+        case 8 // uint8
+            assert_checkequal(bitset(x, pos), uint8RefOne);
+            assert_checkequal(bitset(x, pos, v), uint8RefOne);
+        case 16 // uint16
+            assert_checkequal(bitset(x, pos), uint16RefOne);
+            assert_checkequal(bitset(x, pos, v), uint16RefOne);
+        case 32 // uint32
+            assert_checkequal(bitset(x, pos), uint32RefOne);
+            assert_checkequal(bitset(x, pos, v), uint32RefOne);
+        end
+    else
+        select typeOfx
+        case 0
+            assert_checkequal(bitset(x, pos, v), dbRefZero);
+        case 8
+            assert_checkequal(bitset(x, pos, v), uint8RefZero);
+        case 16
+            assert_checkequal(bitset(x, pos, v), uint16RefZero);
+        case 32
+            assert_checkequal(bitset(x, pos, v), uint32RefZero);
+        end
+    end
+endfunction
+
+clear "createValues"
+function [dbValue, dbPos, dbBitValue, ...
+    uint8Value, uint8Pos, uint8BitValue, ...
+    uint16Value, uint16Pos, uint16BitValue, ...
+    uint32Value, uint32Pos, uint32BitValue] = createValues(value, pos, bitValue)
+    // double
+    dbValue = value;
+    dbPos = pos;
+    dbBitValue = bitValue
+    // uint8
+    uint8Value = uint8(value);
+    uint8Pos = uint8(pos);
+    uint8BitValue = uint8(bitValue);
+    // uint16
+    uint16Value = uint16(value);
+    uint16Pos = uint16(pos);
+    uint16BitValue = uint16(bitValue);
+    // uint32
+    uint32Value = uint32(value);
+    uint32Pos = uint32(pos);
+    uint32BitValue = uint32(bitValue);
+endfunction
+
+clear "createReference";
+function [dbRefOne, dbRefZero, ...
+    uint8RefOne, uint8RefZero, ...
+    uint16RefOne, uint16RefZero, ...
+    uint32RefOne, uint32RefZero] = createReference(refOne, refZero)
+    dbRefOne = refOne;
+    dbRefZero = refZero;
+    uint8RefOne = uint8(dbRefOne);
+    uint16RefOne = uint16(dbRefOne);
+    uint32RefOne = uint32(dbRefOne);
+    uint8RefZero = uint8(dbRefZero);
+    uint16RefZero = uint16(dbRefZero);
+    uint32RefZero = uint32(dbRefZero);
+endfunction
+
+// check input arguments
+lstr = gettext("%s: Wrong number of input argument(s): At least %d expected.\n");
+errmsg = msprintf (lstr, "bitset", 2);
+assert_checkerror("bitset(1)", errmsg);
+assert_checkerror("bitset()", errmsg);
+lstr = gettext("%s: Wrong size for input arguments: Same sizes expected.\n");
+errmsg = msprintf (lstr, "bitset");
+assert_checkerror("bitset([], [1, 2])", errmsg);
+lstr = gettext("%s: Wrong value for input argument #%d: 0 or 1 expected.\n");
+errmsg = msprintf (lstr, "bitset", 3);
+assert_checkerror("bitset(1, 1, 3)", errmsg);
+assert_checkerror("bitset(1, 1, %t)", errmsg);
+assert_checkerror("bitset([1, 2], [1, 1], [2, 0])", errmsg);
+assert_checkerror("bitset([1; 2; 3], [1; 1; 1], [0; 0; 4])", errmsg);
+lstr = gettext("%s: Wrong size for input arguments: Same sizes expected.\n");
+errmsg = msprintf (lstr, "bitset");
+assert_checkerror("bitset(1, [1, 2], 1)", errmsg);
+assert_checkerror("bitset([1, 2], [1, 2, 3], 1)", errmsg);
+assert_checkerror("bitset([1, 2, 3], [1, 2, 3], 1)", errmsg);
+lstr = gettext("%s: Wrong type for input argument #%d: Scalar/matrix/hypermatrix of unsigned integers expected.\n");
+errmsg = msprintf (lstr, "bitset", 1);
+assert_checkerror("bitset(""1"", 1, 1)", errmsg);
+assert_checkerror("bitset(poly(0,""s""), 1, 1)", errmsg);
+assert_checkerror("bitset([1, -1], [1, 0], [1, 0])", errmsg);
+assert_checkerror("bitset([0.5, 0.2], [1, 0], [1, 0])", errmsg);
+assert_checkerror("bitset([%t, %t], [1, 0], [1, 0])", errmsg);
+assert_checkerror("bitset(int32([1, 1]), [1, 0], [1, 0])", errmsg);
+assert_checkerror("bitset(int16([1, 1]), [1, 0], [1, 0])", errmsg);
+assert_checkerror("bitset(int8([1, 1]), [1, 0], [1, 0])", errmsg);
+errmsg = msprintf (lstr, "bitset", 2);
+assert_checkerror("bitset(1,""1"", 1)", errmsg);
+assert_checkerror("bitset(1, poly(0,""s""), 1)", errmsg);
+assert_checkerror("bitset([1, 0], [1, -1], [1, 0])", errmsg);
+assert_checkerror("bitset([1, 0], [0.5, 0.2], [1, 0])", errmsg);
+assert_checkerror("bitset([1; 0], [%t; %t], [1; 0])", errmsg);
+assert_checkerror("bitset([1, 0], int32([1, 1]), [1, 0])", errmsg);
+assert_checkerror("bitset([1, 0], int16([1, 1]), [1, 0])", errmsg);
+assert_checkerror("bitset([1, 0], int8([1, 1]), [1, 0])", errmsg);
+lstr = gettext("%s: Wrong value for input argument #%d: Must be between %d and %d.\n");
+errmsg = msprintf (lstr, "bitset", 2, 1, 52);
+assert_checkerror("bitset([1, 0], [1, 53], [1, 0])", errmsg);
+assert_checkerror("bitset([1, 0], [0, 5], [1, 0])", errmsg);
+errmsg = msprintf (lstr, "bitset", 2, 1, 8);
+assert_checkerror("bitset(uint8([1, 0; 1, 0]), [1, 2; 1, 9], [1, 0; 1, 1])", errmsg);
+assert_checkerror("bitset(uint8([1, 0; 1, 0]), [1, 0; 0, 1], [1, 0; 1, 1])", errmsg);
+errmsg = msprintf (lstr, "bitset", 2, 1, 16);
+assert_checkerror("bitset(uint16([1, 0; 1, 0]), [1, 17; 1, 9], [1, 0; 1, 1])", errmsg);
+assert_checkerror("bitset(uint16([1, 0; 1, 0]), [1, 0; 0, 1], [1, 0; 1, 1])", errmsg);
+errmsg = msprintf (lstr, "bitset", 2, 1, 32);
+assert_checkerror("bitset(uint32([1, 0; 1, 0]), [1, 17; 33, 1], [1, 0; 1, 1])", errmsg);
+assert_checkerror("bitset(uint32([1, 0; 1, 0]), [1, 1; 0, 1], [1, 0; 1, 1])", errmsg);
+
+// check results
+// create value to check
+value = [9, 10, 11, 12, 13, 14, 15];
+position = [2, 3, 4, 5, 6, 7, 8];
+bitValue = zeros(1:7);
+[dbValue, dbPos, dbBitValue, ...
+uint8Value, uint8Pos, uint8BitValue, ...
+uint16Value, uint16Pos, uint16BitValue, ...
+uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
+
+// create references
+refOne = [11, 14, 11, 28, 45, 78, 143];
+refZero = [9, 10, 3, 12, 13, 14, 15];
+[dbRefOne, dbRefZero, ...
+uint8RefOne, uint8RefZero, ...
+uint16RefOne, uint16RefZero, ...
+uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
+
+// check only the same types
+// only double
+checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
+// only uint8
+checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
+checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
+// only uint16
+checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
+checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
+// only uint32
+checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
+checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
+
+// check mixte types
+// double
+checkBitset(dbValue, uint8Pos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, uint8Pos, dbBitValue, %f, 0);
+checkBitset(dbValue, uint8Pos, uint8BitValue, %f, 0);
+checkBitset(dbValue, uint16Pos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, uint16Pos, dbBitValue, %f, 0);
+checkBitset(dbValue, uint16Pos, uint8BitValue, %f, 0);
+checkBitset(dbValue, uint32Pos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, uint32Pos, dbBitValue, %f, 0);
+// uint8
+checkBitset(uint8Value, dbPos, dbBitValue + 1, %t, 8);
+checkBitset(uint8Value, dbPos, dbBitValue, %f, 8);
+checkBitset(uint8Value, uint16Pos, uint16BitValue + 1, %t, 8);
+checkBitset(uint8Value, uint16Pos, dbBitValue, %f, 8);
+checkBitset(uint8Value, uint32Pos, uint8BitValue, %f, 8);
+checkBitset(uint8Value, uint32Pos, dbBitValue + 1, %t, 8);
+// uint16
+checkBitset(uint16Value, dbPos, dbBitValue + 1, %t, 16);
+checkBitset(uint16Value, dbPos, dbBitValue, %f, 16);
+checkBitset(uint16Value, uint8Pos, uint16BitValue + 1, %t, 16);
+checkBitset(uint16Value, uint8Pos, dbBitValue, %f, 16);
+checkBitset(uint16Value, uint32Pos, uint8BitValue, %f, 16);
+checkBitset(uint16Value, uint32Pos, dbBitValue + 1, %t, 16);
+// uint32
+checkBitset(uint32Value, dbPos, uint32BitValue + 1, %t, 32);
+checkBitset(uint32Value, dbPos, uint32BitValue, %f, 32);
+checkBitset(uint32Value, uint16Pos, uint16BitValue + 1, %t, 32);
+checkBitset(uint32Value, uint16Pos, dbBitValue, %f, 32);
+checkBitset(uint32Value, uint8Pos, uint8BitValue, %f, 32);
+checkBitset(uint32Value, uint8Pos, dbBitValue + 1, %t, 32);
+
+
+// create value to check
+value = [4; 5; 6];
+position = [1; 2; 3];
+bitValue = zeros(1:3)';
+[dbValue, dbPos, dbBitValue, ...
+uint8Value, uint8Pos, uint8BitValue, ...
+uint16Value, uint16Pos, uint16BitValue, ...
+uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
+
+// create references
+refOne = [5; 7; 6];
+refZero = [4; 5; 2];
+[dbRefOne, dbRefZero, ...
+uint8RefOne, uint8RefZero, ...
+uint16RefOne, uint16RefZero, ...
+uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
+
+// check values
+// double
+checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
+// uint8
+checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
+checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
+// uint16
+checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
+checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
+// uint32
+checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
+checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
+
+// create value to check
+value = [1, 2, 3; 4, 5, 6];
+position = [2, 2, 2; 3, 3, 3];
+bitValue = zeros(2, 3);
+[dbValue, dbPos, dbBitValue, ...
+uint8Value, uint8Pos, uint8BitValue, ...
+uint16Value, uint16Pos, uint16BitValue, ...
+uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
+
+// create references
+refOne = [3, 2, 3; 4, 5, 6];
+refZero = [1, 0, 1; 0, 1, 2];
+[dbRefOne, dbRefZero, ...
+uint8RefOne, uint8RefZero, ...
+uint16RefOne, uint16RefZero, ...
+uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
+
+// check values
+// double
+checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
+// uint8
+checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
+checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
+// uint16
+checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
+checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
+// uint32
+checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
+checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
+
+// create value to check
+value = hypermat([2 3 1 2], 1:12);
+position = ones(value)*3;
+position(1:6) = 4;
+bitValue = hypermat(size(value), zeros(1:12));
+[dbValue, dbPos, dbBitValue, ...
+uint8Value, uint8Pos, uint8BitValue, ...
+uint16Value, uint16Pos, uint16BitValue, ...
+uint32Value, uint32Pos, uint32BitValue] = createValues(value, position, bitValue);
+
+// create references
+refOne = [9, 10, 11, 12, 13, 14, 7, 12, 13, 14, 15, 12];
+refZero = [1, 2, 3, 4, 5, 6, 3, 8, 9, 10, 11, 8];
+refOne = hypermat([2 3 1 2], refOne);
+refZero = hypermat([2 3 1 2], refZero);
+[dbRefOne, dbRefZero, ...
+uint8RefOne, uint8RefZero, ...
+uint16RefOne, uint16RefZero, ...
+uint32RefOne, uint32RefZero] = createReference(refOne, refZero);
+
+// check values
+// double
+checkBitset(dbValue, dbPos, dbBitValue + 1, %t, 0);
+checkBitset(dbValue, dbPos, dbBitValue, %f, 0);
+// uint8
+checkBitset(uint8Value, uint8Pos, uint8BitValue + 1, %t, 8);
+checkBitset(uint8Value, uint8Pos, uint8BitValue, %f, 8);
+// uint16
+checkBitset(uint16Value, uint16Pos, uint16BitValue + 1, %t, 16);
+checkBitset(uint16Value, uint16Pos, uint16BitValue, %f, 16);
+// uint32
+checkBitset(uint32Value, uint32Pos, uint32BitValue + 1, %t, 32);
+checkBitset(uint32Value, uint32Pos, uint32BitValue, %f, 32);
+
index 16a3169..301ca7e 100644 (file)
@@ -10,4 +10,4 @@ assert_checkerror("bitset(2)",[],10000);
 assert_checkerror("bitset(""aze"")",[],10000);
 assert_checkerror("bitset(-25, 5)",[],10000);
 a=[170,82,24,89,92,59,220,141];
-assert_checkequal(bitset(a,1), [171,83,25,89,93,59,221,141]);
+assert_checkequal(bitset(a, ones(1:8)), [171,83,25,89,93,59,221,141]);
index 5383c7b..cb2320e 100644 (file)
@@ -14,4 +14,4 @@ assert_checkerror("bitset(""aze"")",[],10000);
 
 assert_checkerror("bitset(-25, 5)",[],10000);
 a=[170,82,24,89,92,59,220,141];
-assert_checkequal(bitset(a,1), [171,83,25,89,93,59,221,141]);
+assert_checkequal(bitset(a, ones(1:8)), [171,83,25,89,93,59,221,141]);