* Bug #9385 fixed - The type checking in trigonometric functions has been added. 55/11955/2
Adeline CARNIS [Fri, 5 Jul 2013 14:15:55 +0000 (16:15 +0200)]
Change-Id: I05c77a9188f1d2ab5aa4523486207426344bfb5e

33 files changed:
scilab/CHANGES_5.5.X
scilab/modules/elementary_functions/macros/acosd.sci
scilab/modules/elementary_functions/macros/acot.sci
scilab/modules/elementary_functions/macros/acotd.sci
scilab/modules/elementary_functions/macros/acoth.sci
scilab/modules/elementary_functions/macros/acsc.sci
scilab/modules/elementary_functions/macros/acscd.sci
scilab/modules/elementary_functions/macros/acsch.sci
scilab/modules/elementary_functions/macros/asec.sci
scilab/modules/elementary_functions/macros/asecd.sci
scilab/modules/elementary_functions/macros/asech.sci
scilab/modules/elementary_functions/macros/asind.sci
scilab/modules/elementary_functions/macros/atand.sci
scilab/modules/elementary_functions/macros/cosd.sci
scilab/modules/elementary_functions/macros/cotd.sci
scilab/modules/elementary_functions/macros/cotg.sci
scilab/modules/elementary_functions/macros/csc.sci
scilab/modules/elementary_functions/macros/cscd.sci
scilab/modules/elementary_functions/macros/csch.sci
scilab/modules/elementary_functions/macros/csgn.sci
scilab/modules/elementary_functions/macros/sec.sci
scilab/modules/elementary_functions/macros/secd.sci
scilab/modules/elementary_functions/macros/sech.sci
scilab/modules/elementary_functions/macros/sinc.sci
scilab/modules/elementary_functions/macros/sind.sci
scilab/modules/elementary_functions/macros/tand.sci
scilab/modules/elementary_functions/macros/tanh.sci
scilab/modules/elementary_functions/macros/tanhm.sci
scilab/modules/elementary_functions/macros/tanm.sci
scilab/modules/elementary_functions/tests/nonreg_tests/bug_7691.dia.ref
scilab/modules/elementary_functions/tests/nonreg_tests/bug_7691.tst
scilab/modules/elementary_functions/tests/nonreg_tests/bug_9385.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/nonreg_tests/bug_9385.tst [new file with mode: 0644]

index f4d3b3a..493d8b0 100644 (file)
@@ -299,6 +299,8 @@ Bug fixes
 
 * Bug #9109 fixed - nfreq tagged as obsolete.
 
+* Bug #9385 fixed - The type checking in trigonometric functions has been added.
+
 * Bug #9459 fixed - Default values of the optional plot3d arguments were not documented.
 
 * Bug #9601 fixed - Cylinder demo failed with a bad value.
index 1b12df4..a1ded81 100644 (file)
@@ -15,7 +15,7 @@ function y = acosd(x)
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"acosd", 1));
     end
 
-    if ~isreal(x)
+    if type(x) <> 1 | ~isreal(x) then
         error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"acosd",1));
     end
     if min(x)<-1|max(x)>1 then
index de53212..65e836d 100644 (file)
@@ -15,6 +15,10 @@ function y = acot(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"), "acot", 1));
     end
+    
+    if type(x) <> 1 then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"), "acot", 1));
+    end
 
     y = %pi/2-atan(x);
 endfunction
index 8fb0aa8..4176bdd 100644 (file)
@@ -15,7 +15,7 @@ function y = acotd(x)
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"), "acotd", 1));
     end
 
-    if ~isreal(x)
+    if type(x) <> 1 | ~isreal(x) then
         error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"acotd",1));
     end
     y = 90-atand(x);
index fbcdd00..e291ac6 100644 (file)
@@ -13,11 +13,15 @@ function y = acoth(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"), "acoth", 1));
     end
+    
+    if and(type(x) <> [1 5]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"), "acoth", 1));
+    end
 
-    if isreal(x)&abs(x)>=1 then //the result is real
+    if isreal(x) & abs(x)>=1 then //the result is real
         y = atanh(ones(x)./x)
     else
-        y = atanh(x)+%i*%pi/2*csgn(%i*(x-1));
+        y = atanh(x) + %i*%pi/2*csgn(%i*(x-1));
     end
 
 endfunction
index f352ecc..b6cfe06 100644 (file)
@@ -15,6 +15,10 @@ function y = acsc(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"acsc", 1));
     end
+    
+    if and(type(x) <> [1 5]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"), "acsc", 1));
+    end
 
     y = asin(ones(x)./x);
 endfunction
index f0b6df2..96ab8cb 100644 (file)
@@ -17,8 +17,8 @@ function y = acscd(x)
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"acscd", 1));
     end
 
-    if ~isreal(x) then
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"acscd",1));
+    if and(type(x) <> [1 5]) | ~isreal(x) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real sparse or full matrix expected.\n"),"acscd",1));
     end
     y = 180/%pi*asin(ones(x)./x);
 endfunction
index e5c0f4d..3719c4f 100644 (file)
@@ -16,6 +16,10 @@ function y = acsch(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"acsch", 1));
     end
+    
+    if and(type(x) <> [1 5]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"), "acsch", 1));
+    end
 
     y = asinh(ones(x)./x);
 endfunction
index 805f79d..784590f 100644 (file)
@@ -13,6 +13,10 @@ function y = asec(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"asec", 1));
     end
+    
+    if and(type(x) <> [1 5]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"), "asec", 1));
+    end
 
     y = acos(ones(x)./x);
 endfunction
index 2bbdf1e..ce531f6 100644 (file)
@@ -16,8 +16,8 @@ function y = asecd(x)
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"asecd", 1));
     end
 
-    if ~isreal(x) then
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"asecd",1));
+    if and(type(x) <> [1 5]) | ~isreal(x) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real sparse or full matrix expected.\n"),"asecd",1));
     end
     y = 180/%pi*acos(ones(x)./x);
 endfunction
index 545db17..a3ac2d0 100644 (file)
@@ -17,6 +17,10 @@ function y = asech(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"asech", 1));
     end
+    
+    if and(type(x) <> [1 5]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"asech", 1));
+    end
 
     y = acosh(ones(x)./x);
 endfunction
index 54e4daa..55de04d 100644 (file)
@@ -17,7 +17,7 @@ function y = asind(x)
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"asind", 1));
     end
 
-    if ~isreal(x)
+    if  type(x) <> 1 | ~isreal(x) then
         error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"asind",1));
     end
     if min(x)<-1|max(x)>1 then
index 68ae5da..20a58c6 100644 (file)
@@ -17,11 +17,12 @@ function z = atand(x,y)
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"atand", 1));
     end
 
-    if ~isreal(x)
+    if type(x) <> 1 | ~isreal(x) then
         error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"atand",1));
     end
+
     if argn(2)==2 then
-        if ~isreal(y)
+        if type(y) <> 1 | ~isreal(y) then
             error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"atand",2));
         end
         z = 180/%pi*atan(x,y);
index b527221..8e2443f 100644 (file)
@@ -15,10 +15,11 @@ function x = cosd(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"cosd", 1));
     end
-
-    if ~isreal(x) then
+    
+    if type(x) <> 1 | ~isreal(x) then
         error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"cosd",1));
     end
+
     n = round(x/90);
     x = x - n*90;
     m = pmodulo(n,4);
index a9b0fe5..479fbca 100644 (file)
@@ -14,10 +14,11 @@ function y = cotd(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"cotd", 1));
     end
-
-    if ~isreal(x) then
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"cotd",1));
+    
+    if type(x) <> 1 | ~isreal(x) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"), "cotd", 1));
     end
+
     y = ones(x)./tand(x);
 endfunction
 
index 72711a1..a0294b4 100644 (file)
@@ -22,5 +22,6 @@ function [t] = cotg(z)
     if type(z)<>1 then
         error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"cotg",1));
     end
+    
     t = 1 ./tan(z)
 endfunction
index a1a8a78..f6fe462 100644 (file)
@@ -13,6 +13,10 @@ function y = csc(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"csc", 1));
     end
+    
+    if and(typeof(x) <> ["constant", "sparse", "hypermatrix"]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"), "csc", 1));
+    end
 
     y = ones(x)./sin(x);
 endfunction
index d598194..2c2198a 100644 (file)
@@ -14,10 +14,11 @@ function x = cscd(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"cscd", 1));
     end
-
-    if ~isreal(x) then
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"cscd",1));
+    
+    if type(x) <> 1 | ~isreal(x) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"), "cscd", 1));
     end
+
     n = round(x/90);
     x = x - n*90;
     m = pmodulo(n,4);
index 2073c36..cb51b2e 100644 (file)
@@ -13,6 +13,10 @@ function y = csch(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"csch", 1));
     end
+    
+    if type(x) <> 1 then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"csch", 1));
+    end
 
     y = ones(x)./sinh(x);
 endfunction
index 7ac22c6..656070a 100644 (file)
@@ -17,6 +17,10 @@ function s = csgn(z)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"csgn", 1));
     end
+    
+    if and(typeof(z) <> ["constant" "sparse" "hypermat"]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"), "csgn", 1));
+    end
 
     s = -ones(z);
     s(real(z)>0|(real(z)==0&imag(z)>0))=1
index c88a4fe..6f2ec4d 100644 (file)
@@ -14,6 +14,10 @@ function y = sec(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"sec", 1));
     end
+    
+    if and(typeof(x) <> ["constant", "sparse"," hypermatrix"]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"),"sec", 1));
+    end
 
     y = ones(x)./cos(x);
 endfunction
index 3e84756..a724e6b 100644 (file)
@@ -16,7 +16,7 @@ function x = secd(x)
     end
 
     // Secant argument in degree
-    if ~isreal(x) then
+    if type(x) <> 1 | ~isreal(x) then
         error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"secd",1));
     end
 
index 856ecf5..61fc589 100644 (file)
@@ -14,6 +14,10 @@ function y = sech(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"sech", 1));
     end
+    
+    if type(x) <> 1 then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"sech",1));
+    end
     y = ones(x)./cosh(x);
 
 endfunction
index 0c14dd7..ee54e6a 100644 (file)
@@ -17,6 +17,10 @@ function y=sinc(x,fl)
     if rhs < 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"sinc", 1));
     end
+    
+    if and(typeof(x)<>["constant", "sparse", "hypermatrix"]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"),"sinc",1));
+    end
 
     if argn(2) == 2 then // for compatibility
         warning("obsolete use of sinc, use filt_sinc instead")
index 79a9bdc..af895bb 100644 (file)
@@ -17,10 +17,11 @@ function x = sind(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"sind", 1));
     end
-
-    if ~isreal(x) then
+    
+    if type(x)<>1 | ~isreal(x) then
         error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"sind",1));
     end
+
     n = round(x/90);
     x = x - n*90;
     m = pmodulo(n,4);
index 63f4cfb..48b63d5 100644 (file)
@@ -19,10 +19,11 @@ function y = tand(x)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"tand", 1));
     end
-
-    if ( ~isreal(x) ) then
+    
+    if type(x)<>1 | ~isreal(x) then
         error(msprintf(gettext("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"tand",1));
     end
+
     // Argument reduction toward [-90,90[
     n = round(x / 180);
     x = x - n * 180;
index ed6c031..b741369 100644 (file)
@@ -23,7 +23,7 @@ function [t]=tanh(z)
     end
 
     if type(z)<>1 then
-        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"sinhm",1));
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"tanh",1));
     end
 
     if isreal(z) then
index 559fd77..442a5bb 100644 (file)
@@ -15,6 +15,10 @@ function x=tanhm(a)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"tanhm",1));
     end
+    
+    if and(type(a) <> [1, 5]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"), "tanhm", 1));
+    end
 
     if a==[] then x=[],return,end
 
index 6eb4da4..c1d37c7 100644 (file)
@@ -15,6 +15,10 @@ function x=tanm(a)
     if rhs <> 1 then
         error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"tanm",1));
     end
+    
+    if type(a) <> 1 then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"), "tanm", 1));
+    end
 
     if a==[] then x=[],return,end
 
diff --git a/scilab/modules/elementary_functions/tests/nonreg_tests/bug_9385.dia.ref b/scilab/modules/elementary_functions/tests/nonreg_tests/bug_9385.dia.ref
new file mode 100644 (file)
index 0000000..92cce45
--- /dev/null
@@ -0,0 +1,99 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- CLI SHELL MODE -->
+// <-- Non-regression test for bug 9385 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=9385
+//
+// <-- Short Description -->
+//    The type checking in trigonometric functions has been added
+// =============================================================================
+assert_checkfalse(execstr("tanm(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"), "tanm", 1);
+assert_checkerror("tanm(""x"")", refMsg);
+assert_checkfalse(execstr("tanhm(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"), "tanhm", 1);
+assert_checkerror("tanhm(""x"")", refMsg);
+assert_checkfalse(execstr("tanh(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"), "tanh", 1);
+assert_checkerror("tanh(""x"")", refMsg);
+assert_checkfalse(execstr("tand(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"tand",1);
+assert_checkerror("tand(""x"")", refMsg);
+assert_checkfalse(execstr("sind(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"sind",1);
+assert_checkerror("sind(""x"")", refMsg);
+assert_checkfalse(execstr("sinc(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"),"sinc",1);
+assert_checkerror("sinc(""x"")", refMsg);
+assert_checkfalse(execstr("sech(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"sech",1);
+assert_checkerror("sech(""x"")", refMsg);
+assert_checkfalse(execstr("secd(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"secd",1);
+assert_checkerror("secd(""x"")", refMsg);
+assert_checkfalse(execstr("sec(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"),"sec",1);
+assert_checkerror("sec(""x"")", refMsg);
+assert_checkfalse(execstr("csgn(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"), "csgn", 1);
+assert_checkerror("csgn(""x"")", refMsg);
+assert_checkfalse(execstr("csch(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"csch", 1);
+assert_checkerror("csch(""x"")", refMsg);
+assert_checkfalse(execstr("cscd(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"), "cscd", 1);
+assert_checkerror("cscd(""x"")", refMsg);
+assert_checkfalse(execstr("csc(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"), "csc", 1);
+assert_checkerror("csc(""x"")", refMsg);
+assert_checkfalse(execstr("cotd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"), "cotd", 1);
+assert_checkerror("cotd(""x"")", refMsg);
+assert_checkfalse(execstr("cosd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"cosd",1);
+assert_checkerror("cosd(""x"")", refMsg);
+assert_checkfalse(execstr("atand(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"atand",1);
+assert_checkerror("atand(""x"")", refMsg);
+assert_checkfalse(execstr("atand(1, ""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"atand",2);
+assert_checkerror("atand(1, ""x"")", refMsg);
+assert_checkfalse(execstr("asind(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"asind",1);
+assert_checkerror("asind(""x"")", refMsg);
+assert_checkfalse(execstr("asech(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"asech", 1);
+assert_checkerror("asech(""x"")", refMsg);
+assert_checkfalse(execstr("asecd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real sparse or full matrix expected.\n"),"asecd",1);
+assert_checkerror("asecd(""x"")", refMsg);
+assert_checkfalse(execstr("asec(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"asec",1);
+assert_checkerror("asec(""x"")", refMsg);
+assert_checkfalse(execstr("acsch(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"acsch",1);
+assert_checkerror("acsch(""x"")", refMsg);
+assert_checkfalse(execstr("acscd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real sparse or full matrix expected.\n"),"acscd",1);
+assert_checkerror("acscd(""x"")", refMsg);
+assert_checkfalse(execstr("acsc(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"acsc",1);
+assert_checkerror("acsc(""x"")", refMsg);
+assert_checkfalse(execstr("acoth(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"acoth",1);
+assert_checkerror("acoth(""x"")", refMsg);
+assert_checkfalse(execstr("acotd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"acotd",1);
+assert_checkerror("acotd(""x"")", refMsg);
+assert_checkfalse(execstr("acot(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"acot", 1);
+assert_checkerror("acot(""x"")", refMsg);
+assert_checkfalse(execstr("acosd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"acosd",1);
+assert_checkerror("acosd(""x"")", refMsg);
diff --git a/scilab/modules/elementary_functions/tests/nonreg_tests/bug_9385.tst b/scilab/modules/elementary_functions/tests/nonreg_tests/bug_9385.tst
new file mode 100644 (file)
index 0000000..52ddb17
--- /dev/null
@@ -0,0 +1,131 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- CLI SHELL MODE -->
+
+// <-- Non-regression test for bug 9385 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=9385
+//
+// <-- Short Description -->
+//    The type checking in trigonometric functions has been added
+// =============================================================================
+
+assert_checkfalse(execstr("tanm(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"), "tanm", 1);
+assert_checkerror("tanm(""x"")", refMsg);
+
+assert_checkfalse(execstr("tanhm(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"), "tanhm", 1);
+assert_checkerror("tanhm(""x"")", refMsg);
+
+assert_checkfalse(execstr("tanh(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"), "tanh", 1);
+assert_checkerror("tanh(""x"")", refMsg);
+
+assert_checkfalse(execstr("tand(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"tand",1);
+assert_checkerror("tand(""x"")", refMsg);
+
+assert_checkfalse(execstr("sind(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"sind",1);
+assert_checkerror("sind(""x"")", refMsg);
+
+assert_checkfalse(execstr("sinc(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"),"sinc",1);
+assert_checkerror("sinc(""x"")", refMsg);
+
+assert_checkfalse(execstr("sech(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"sech",1);
+assert_checkerror("sech(""x"")", refMsg);
+
+assert_checkfalse(execstr("secd(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"secd",1);
+assert_checkerror("secd(""x"")", refMsg);
+
+assert_checkfalse(execstr("sec(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"),"sec",1);
+assert_checkerror("sec(""x"")", refMsg);
+
+assert_checkfalse(execstr("csgn(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"), "csgn", 1);
+assert_checkerror("csgn(""x"")", refMsg);
+
+assert_checkfalse(execstr("csch(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"csch", 1);
+assert_checkerror("csch(""x"")", refMsg);
+
+assert_checkfalse(execstr("cscd(""x"")"   ,"errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"), "cscd", 1);
+assert_checkerror("cscd(""x"")", refMsg);
+
+assert_checkfalse(execstr("csc(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix or hypermatrix expected.\n"), "csc", 1);
+assert_checkerror("csc(""x"")", refMsg);
+
+assert_checkfalse(execstr("cotd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"), "cotd", 1);
+assert_checkerror("cotd(""x"")", refMsg);
+
+assert_checkfalse(execstr("cosd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"cosd",1);
+assert_checkerror("cosd(""x"")", refMsg);
+
+assert_checkfalse(execstr("atand(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"atand",1);
+assert_checkerror("atand(""x"")", refMsg);
+
+assert_checkfalse(execstr("atand(1, ""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"atand",2);
+assert_checkerror("atand(1, ""x"")", refMsg);
+
+assert_checkfalse(execstr("asind(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"asind",1);
+assert_checkerror("asind(""x"")", refMsg);
+
+assert_checkfalse(execstr("asech(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"asech", 1);
+assert_checkerror("asech(""x"")", refMsg);
+
+assert_checkfalse(execstr("asecd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real sparse or full matrix expected.\n"),"asecd",1);
+assert_checkerror("asecd(""x"")", refMsg);
+
+assert_checkfalse(execstr("asec(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"asec",1);
+assert_checkerror("asec(""x"")", refMsg);
+
+assert_checkfalse(execstr("acsch(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"acsch",1);
+assert_checkerror("acsch(""x"")", refMsg);
+
+assert_checkfalse(execstr("acscd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real sparse or full matrix expected.\n"),"acscd",1);
+assert_checkerror("acscd(""x"")", refMsg);
+
+assert_checkfalse(execstr("acsc(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"acsc",1);
+assert_checkerror("acsc(""x"")", refMsg);
+
+assert_checkfalse(execstr("acoth(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex, sparse or full matrix expected.\n"),"acoth",1);
+assert_checkerror("acoth(""x"")", refMsg);
+
+assert_checkfalse(execstr("acotd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"acotd",1);
+assert_checkerror("acotd(""x"")", refMsg);
+
+assert_checkfalse(execstr("acot(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real or complex matrix expected.\n"),"acot", 1);
+assert_checkerror("acot(""x"")", refMsg);
+
+assert_checkfalse(execstr("acosd(""x"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Real matrix expected.\n"),"acosd",1);
+assert_checkerror("acosd(""x"")", refMsg);
+
+