* Bug #14681 fixed - Short-circuited AND operation was not possible with double matri... 87/18387/5
Pierre-Aime AGNEL [Mon, 25 Jul 2016 10:05:44 +0000 (12:05 +0200)]
Change-Id: I463ac0277d10a2db1f90bce7f4c4fc2900e18a2d

60 files changed:
scilab/CHANGES.md
scilab/modules/ast/includes/operations/types_and.hxx
scilab/modules/ast/includes/operations/types_or.hxx
scilab/modules/ast/src/cpp/operations/types_and.cpp
scilab/modules/ast/src/cpp/operations/types_or.cpp
scilab/modules/ast/tests/nonreg_tests/bug_13918.dia.ref
scilab/modules/ast/tests/nonreg_tests/bug_13918.tst
scilab/modules/ast/tests/nonreg_tests/bug_14681.dia.ref [new file with mode: 0644]
scilab/modules/ast/tests/nonreg_tests/bug_14681.tst [new file with mode: 0644]
scilab/modules/ast/tests/unit_tests/or_and.dia.ref
scilab/modules/ast/tests/unit_tests/or_and.tst
scilab/modules/elementary_functions/help/en_US/and_op.xml
scilab/modules/elementary_functions/help/en_US/or_op.xml
scilab/modules/elementary_functions/help/fr_FR/and_op.xml
scilab/modules/elementary_functions/help/fr_FR/or_op.xml
scilab/modules/elementary_functions/help/ja_JP/and_op.xml
scilab/modules/elementary_functions/help/ja_JP/or_op.xml
scilab/modules/elementary_functions/help/ru_RU/and_op.xml
scilab/modules/elementary_functions/help/ru_RU/or_op.xml
scilab/modules/overloading/macros/%b_g_i.sci [moved from scilab/modules/overloading/macros/%s_h_b.sci with 81% similarity]
scilab/modules/overloading/macros/%b_g_sp.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%b_h_i.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%b_h_sp.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%hm_g_hm.sci [deleted file]
scilab/modules/overloading/macros/%hm_h_hm.sci [deleted file]
scilab/modules/overloading/macros/%i_g_b.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_g_s.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_g_sp.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_g_spb.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_h_b.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_h_s.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_h_sp.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_h_spb.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%s_g_i.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%s_g_s.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%s_g_sp.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%s_g_spb.sci [moved from scilab/modules/overloading/macros/%spb_h_spb.sci with 54% similarity]
scilab/modules/overloading/macros/%s_h_i.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%s_h_s.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%s_h_sp.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%s_h_spb.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_g_b.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_g_i.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_g_s.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_g_sp.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_g_spb.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_h_b.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_h_i.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_h_s.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_h_sp.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_h_spb.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%spb_g_i.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%spb_g_s.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%spb_g_sp.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%spb_g_spb.sci [deleted file]
scilab/modules/overloading/macros/%spb_h_i.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%spb_h_s.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%spb_h_sp.sci [new file with mode: 0644]
scilab/modules/overloading/macros/generic_s_g_s.sci [moved from scilab/modules/overloading/macros/%b_g_s.sci with 81% similarity]
scilab/modules/overloading/macros/generic_s_h_s.sci [moved from scilab/modules/overloading/macros/%b_h_s.sci with 81% similarity]

index fc8d746..427d279 100644 (file)
@@ -147,7 +147,7 @@ Help pages:
 -----------
 
 * fixed / improved:  `members`, `part`, `ode`, `ode_optional_output`, `ode_roots`, `roots`,
-  `printf`, `sprintf`, `iconvert`, `stdev`, `xlabel`
+  `printf`, `sprintf`, `iconvert`, `stdev`, `xlabel`, `and_op`, `or_op`
 * rewritten: `consolebox`, `double`, `isoview`, `householder`, `or`, `and`, `format`, `typeof`, `brackets`, `setlanguage`, `sleep`, `isinf`
 * reorganized:
   - `else`, `elseif`, `end`, `try`, `sciargs`, `global`, `halt`, `empty`, `power`
@@ -258,6 +258,7 @@ Bug Fixes
 * [Bug #14602](http://bugzilla.scilab.org/show_bug.cgi?id=14662) fixed - WRITEC_f block didn't work for x86 machines.
 * [Bug #14648](http://bugzilla.scilab.org/show_bug.cgi?id=14648) fixed - `isinf` returned `%F` for complex numbers with both real and imag infinite parts.
 * [Bug #14662](http://bugzilla.scilab.org/show_bug.cgi?id=14662) fixed - Matrix of strings concatenation with single quote led to a parser error.
+* [Bug #14681](http://bugzilla.scilab.org/show_bug.cgi?id=14681) fixed - Short-circuited AND operation was not possible with double matrices in if and while clauses
 
 ### In 6.0.0 beta-2 and earlier:
 
index e20c55a..8c423cd 100644 (file)
@@ -1,6 +1,7 @@
 /*
  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  *  Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
+ *  Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
@@ -125,9 +126,14 @@ template<typename T, typename U, typename O> inline static void int_and(T l, U r
 }
 
 // &&
-int IntAndInt(types::InternalType* _pL, types::Bool** _pOut);
-int BoolAndBool(types::Bool* _pL, types::Bool** _pOut);
-int SparseBoolAndSparseBool(types::InternalType* _pL, types::Bool** _pOut);
+template<typename T>
+void isValueFalse(T* _pL, types::Bool** _pOut);
+template<>
+void isValueFalse(types::Double* _pL, types::Bool** _pOut);
+template<>
+void isValueFalse(types::SparseBool* _pL, types::Bool** _pOut);
+template<>
+void isValueFalse(types::Sparse* _pL, types::Bool** _pOut);
 
 #undef DECLARE_AND_PROTO
 #endif /* !__TYPES_AND_H__ */
index ee41f4a..e5a1e37 100644 (file)
@@ -1,6 +1,7 @@
 /*
  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  *  Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
+ *  Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
@@ -125,9 +126,13 @@ template<typename T, typename U, typename O> inline static void int_or(T l, U r,
 }
 
 // ||
-int IntOrInt(types::InternalType* _pL, types::Bool** _pOut);
-int DoubleOrDouble(types::Double* _pI1, types::Bool** _pOut);
-int BoolOrBool(types::Bool* _pI1, types::Bool** _pOut);
-int SparseBoolOrSparseBool(types::InternalType* _pL, types::Bool** _pOut);
+template<typename T>
+void isValueTrue(T* _pL, types::Bool** _pOut);
+template<>
+void isValueTrue(types::Double* _pL, types::Bool** _pOut);
+template<>
+void isValueTrue(types::SparseBool* _pL, types::Bool** _pOut);
+template<>
+void isValueTrue(types::Sparse* _pL, types::Bool** _pOut);
 
 #endif /* __TYPES_OR_H__ */
index 24583b7..d44d21c 100644 (file)
@@ -1,6 +1,7 @@
 /*
  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  *  Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
+ *  Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
@@ -400,136 +401,145 @@ void fillAndFunction()
 InternalType* GenericShortcutAnd(InternalType* _pL)
 {
     InternalType* pResult = NULL;
-    if (_pL->isBool())
-    {
-        BoolAndBool(_pL->getAs<Bool>(), (Bool**)&pResult);
-    }
-
-    if (_pL->isInt())
-    {
-        IntAndInt(_pL, (Bool**)&pResult);
-    }
-
-    if (_pL->isSparseBool())
+    switch (_pL->getType())
     {
-        SparseBoolAndSparseBool(_pL, (Bool**)&pResult);
+        case InternalType::ScilabBool :
+            isValueFalse(_pL->getAs<Bool>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabDouble :
+            isValueFalse(_pL->getAs<Double>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt8 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt8 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt16 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt16 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt32 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt32 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt64 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt64 :
+            isValueFalse(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabSparse :
+            isValueFalse(_pL->getAs<SparseBool>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabSparseBool :
+            isValueFalse(_pL->getAs<SparseBool>(), (Bool**)&pResult);
+            break;
+        default:
+            // will return NULL
+            break;
     }
 
     return pResult;
 }
 
-// &
-InternalType* GenericLogicalAnd(InternalType* _pL, InternalType* _pR)
-{
-    InternalType *pResult = NULL;
-
-    and_function bit_and = pAndfunction[_pL->getId()][_pR->getId()];
-    if (bit_and)
-    {
-        pResult = bit_and(_pL, _pR);
-        if (pResult)
-        {
-            return pResult;
-        }
-    }
-
-    /*
-    ** Default case : Return NULL will Call Overloading.
-    */
-    return NULL;
-}
-
-int BoolAndBool(Bool* _pL, Bool** _pOut)
+template<typename T>
+void isValueFalse(T* _pL, types::Bool** _pOut)
 {
     for (int i = 0 ; i < _pL->getSize() ; i++)
     {
         if (_pL->get(i) == 0)
         {
-            //false && something -> false
-            *_pOut = new Bool(0);
-            return 0;
+            if ( !_pL->isComplex() || (_pL->getImg(i) == 0) )
+            {
+                *_pOut = new Bool(0); //false && something -> false
+                return;
+            }
         }
     }
 
     //call non shortcut operation
     *_pOut = NULL;
-    return 0;
+    return;
 }
 
-template <class K>
-static int IntAndInt(K* _pL, Bool** _pOut)
+template<>
+void isValueFalse(Double* _pL, Bool** _pOut)
 {
+    if (_pL->isEmpty())
+    {
+        //call non shorcut operation
+        *_pOut = NULL;
+        return;
+    }
+
     for (int i = 0 ; i < _pL->getSize() ; i++)
     {
         if (_pL->get(i) == 0)
         {
-            //false && something -> false
-            *_pOut = new Bool(0);
-            return 0;
+            if ( !_pL->isComplex() || (_pL->getImg(i) == 0) )
+            {
+                *_pOut = new Bool(0); //false && something -> false
+                return;
+            }
         }
     }
 
     //call non shortcut operation
     *_pOut = NULL;
-    return 0;
+    return;
 }
 
-int IntAndInt(InternalType* _pL, Bool** _pOut)
+template<>
+void isValueFalse(Sparse* _pL, Bool** _pOut)
 {
-    switch (_pL->getType())
+    if (_pL->nonZeros() != (size_t)_pL->getSize())
     {
-        case InternalType::ScilabInt8 :
-        {
-            return IntAndInt(_pL->getAs<Int8>(), _pOut);
-        }
-        case InternalType::ScilabUInt8 :
-        {
-            return IntAndInt(_pL->getAs<UInt8>(), _pOut);
-        }
-        case InternalType::ScilabInt16 :
-        {
-            return IntAndInt(_pL->getAs<Int16>(), _pOut);
-        }
-        case InternalType::ScilabUInt16 :
-        {
-            return IntAndInt(_pL->getAs<UInt16>(), _pOut);
-        }
-        case InternalType::ScilabInt32 :
-        {
-            return IntAndInt(_pL->getAs<Int32>(), _pOut);
-        }
-        case InternalType::ScilabUInt32 :
-        {
-            return IntAndInt(_pL->getAs<UInt32>(), _pOut);
-        }
-        case InternalType::ScilabInt64 :
-        {
-            return IntAndInt(_pL->getAs<Int64>(), _pOut);
-        }
-        case InternalType::ScilabUInt64 :
-        {
-            return IntAndInt(_pL->getAs<UInt64>(), _pOut);
-        }
-        default:
-        {
-            return 3;
-        }
+        *_pOut = new Bool(0);
+        return;
     }
+
+    *_pOut = NULL;
+    return;
 }
 
-int SparseBoolAndSparseBool(InternalType* _pL, Bool** _pOut)
+template<>
+void isValueFalse(SparseBool* _pL, Bool** _pOut)
 {
-    SparseBool* pL = _pL->getAs<SparseBool>();
-    if (pL->nbTrue() != (size_t)pL->getSize())
+    if (_pL->nbTrue() != (size_t)_pL->getSize())
     {
         *_pOut = new Bool(0);
-        return 0;
+        return;
     }
 
     *_pOut = NULL;
-    return 0;
+    return;
 }
 
+// &
+InternalType* GenericLogicalAnd(InternalType* _pL, InternalType* _pR)
+{
+    InternalType *pResult = NULL;
+
+    and_function bit_and = pAndfunction[_pL->getId()][_pR->getId()];
+    if (bit_and)
+    {
+        pResult = bit_and(_pL, _pR);
+        if (pResult)
+        {
+            return pResult;
+        }
+    }
+
+    /*
+    ** Default case : Return NULL will Call Overloading.
+    */
+    return NULL;
+}
 
 template<class T, class U, class O>
 InternalType* and_M_M(T *_pL, U *_pR)
index 4662d0f..762f80e 100644 (file)
@@ -2,6 +2,7 @@
  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  *  Copyright (C) 2012 - Scilab Enterprises - Antoine ELIAS
  *  Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
+ *  Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
@@ -379,14 +380,6 @@ void fillOrFunction()
     scilab_fill_or(ScalarUInt64, Int64, int_S_M, UInt64, Int64, UInt64);
     scilab_fill_or(ScalarUInt64, UInt64, int_S_M, UInt64, UInt64, UInt64);
 
-    scilab_fill_or(ScalarUInt64, ScalarInt8, int_S_S, UInt64, Int8, UInt64);
-    scilab_fill_or(ScalarUInt64, ScalarUInt8, int_S_S, UInt64, UInt8, UInt64);
-    scilab_fill_or(ScalarUInt64, ScalarInt16, int_S_S, UInt64, Int16, UInt64);
-    scilab_fill_or(ScalarUInt64, ScalarUInt16, int_S_S, UInt64, UInt16, UInt64);
-    scilab_fill_or(ScalarUInt64, ScalarInt32, int_S_S, UInt64, Int32, UInt64);
-    scilab_fill_or(ScalarUInt64, ScalarUInt32, int_S_S, UInt64, UInt32, UInt64);
-    scilab_fill_or(ScalarUInt64, ScalarInt64, int_S_S, UInt64, Int64, UInt64);
-    scilab_fill_or(ScalarUInt64, ScalarUInt64, int_S_S, UInt64, UInt64, UInt64);
 
     //boolean sparse
     scilab_fill_or(SparseBool, SparseBool, M_M, SparseBool, SparseBool, SparseBool);
@@ -402,52 +395,53 @@ void fillOrFunction()
 InternalType* GenericShortcutOr(InternalType* _pL)
 {
     InternalType* pResult = NULL;
-
-    if (_pL->isBool())
-    {
-        BoolOrBool(_pL->getAs<Bool>(), (Bool**)&pResult);
-    }
-
-    if (_pL->isDouble())
-    {
-        DoubleOrDouble(_pL->getAs<Double>(), (Bool**)&pResult);
-    }
-
-    if (_pL->isInt())
-    {
-        IntOrInt(_pL, (Bool**)&pResult);
-    }
-
-    if (_pL->isSparseBool())
+    switch (_pL->getType())
     {
-        SparseBoolOrSparseBool(_pL, (Bool**)&pResult);
+        case InternalType::ScilabBool :
+            isValueTrue(_pL->getAs<Bool>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabDouble :
+            isValueTrue(_pL->getAs<Double>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt8 :
+            isValueTrue(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt8 :
+            isValueTrue(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt16 :
+            isValueTrue(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt16 :
+            isValueTrue(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt32 :
+            isValueTrue(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt32 :
+            isValueTrue(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabInt64 :
+            isValueTrue(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabUInt64 :
+            isValueTrue(_pL->getAs<Int8>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabSparse :
+            isValueTrue(_pL->getAs<SparseBool>(), (Bool**)&pResult);
+            break;
+        case InternalType::ScilabSparseBool :
+            isValueTrue(_pL->getAs<SparseBool>(), (Bool**)&pResult);
+            break;
+        default:
+            // will return NULL
+            break;
     }
-
     return pResult;
 }
 
-// |
-InternalType* GenericLogicalOr(InternalType* _pL, InternalType* _pR)
-{
-    InternalType *pResult = NULL;
-
-    or_function bit_or = pOrfunction[_pL->getId()][_pR->getId()];
-    if (bit_or)
-    {
-        pResult = bit_or(_pL, _pR);
-        if (pResult)
-        {
-            return pResult;
-        }
-    }
-
-    /*
-    ** Default case : Return NULL will Call Overloading.
-    */
-    return NULL;
-}
-
-int BoolOrBool(Bool* _pL, Bool** _pOut)
+template<typename T>
+void isValueTrue(T* _pL, types::Bool** _pOut)
 {
     for (int i = 0 ; i < _pL->getSize() ; i++)
     {
@@ -455,108 +449,89 @@ int BoolOrBool(Bool* _pL, Bool** _pOut)
         {
             //call non shortcut opearion
             *_pOut = NULL;
-            return 0;
+            return;
         }
     }
 
+    // All values are different than 0
     *_pOut = new Bool(1); //true || something -> true
-    return 0;
+    return;
 }
 
-int DoubleOrDouble(Double* _pL, Bool** _pOut)
+template<>
+void isValueTrue(Double* _pL, Bool** _pOut)
 {
     if (_pL->isEmpty())
     {
         //call non shorcut operation
         *_pOut = NULL;
-        return 0;
+        return;
     }
 
     for (int i = 0 ; i < _pL->getSize() ; i++)
     {
         if (_pL->get(i) == 0)
         {
-            //call non shortcut operation
-            *_pOut = NULL;
-            return 0;
+            if ( !_pL->isComplex() || (_pL->getImg(i) == 0) )
+            {
+                // Any value is false, call non shortcut operation
+                *_pOut = NULL;
+                return;
+            }
         }
     }
 
-    *_pOut = new Bool(1); //true || something -> true
-    return 0;
+    // All values are True, return True
+    *_pOut = new Bool(1);
+    return;
 }
 
-template <class K>
-static int IntOrInt(K* _pL, Bool** _pOut)
+template<>
+void isValueTrue(Sparse* _pL, Bool** _pOut)
 {
-    for (int i = 0 ; i < _pL->getSize() ; i++)
+    if (_pL->nonZeros() == (size_t)_pL->getSize())
     {
-        if (_pL->get(i) == 0)
-        {
-            //call non shortcut opearion
-            *_pOut = NULL;
-            return 0;
-        }
+        *_pOut = new Bool(1);
+        return;
     }
 
-    *_pOut = new Bool(1); //true || something -> true
-    return 0;
+    *_pOut = NULL;
+    return;
 }
 
-int IntOrInt(InternalType* _pL, Bool** _pOut)
+template<>
+void isValueTrue(SparseBool* _pL, Bool** _pOut)
 {
-    switch (_pL->getType())
+    SparseBool* pL = _pL->getAs<SparseBool>();
+    if (pL->nbTrue() == pL->getSize())
     {
-        case InternalType::ScilabInt8 :
-        {
-            return IntOrInt(_pL->getAs<Int8>(), _pOut);
-        }
-        case InternalType::ScilabUInt8 :
-        {
-            return IntOrInt(_pL->getAs<UInt8>(), _pOut);
-        }
-        case InternalType::ScilabInt16 :
-        {
-            return IntOrInt(_pL->getAs<Int16>(), _pOut);
-        }
-        case InternalType::ScilabUInt16 :
-        {
-            return IntOrInt(_pL->getAs<UInt16>(), _pOut);
-        }
-        case InternalType::ScilabInt32 :
-        {
-            return IntOrInt(_pL->getAs<Int32>(), _pOut);
-        }
-        case InternalType::ScilabUInt32 :
-        {
-            return IntOrInt(_pL->getAs<UInt32>(), _pOut);
-        }
-        case InternalType::ScilabInt64 :
-        {
-            return IntOrInt(_pL->getAs<Int64>(), _pOut);
-        }
-        case InternalType::ScilabUInt64 :
-        {
-            return IntOrInt(_pL->getAs<UInt64>(), _pOut);
-        }
-        default:
-        {
-            return 3;
-        }
+        *_pOut = new Bool(1);
+        return;
     }
+
+    *_pOut = NULL;
+    return;
 }
 
-int SparseBoolOrSparseBool(InternalType* _pL, Bool** _pOut)
+// |
+InternalType* GenericLogicalOr(InternalType* _pL, InternalType* _pR)
 {
-    SparseBool* pL = _pL->getAs<SparseBool>();
-    if (pL->nbTrue() == pL->getSize())
+    InternalType *pResult = NULL;
+
+    or_function bit_or = pOrfunction[_pL->getId()][_pR->getId()];
+    if (bit_or)
     {
-        *_pOut = new Bool(1);
-        return 0;
+        pResult = bit_or(_pL, _pR);
+        if (pResult)
+        {
+            return pResult;
+        }
     }
 
-    *_pOut = NULL;
-    return 0;
+    /*
+    ** Default case : Return NULL will Call Overloading.
+    */
+    return NULL;
 }
 
 template<class T, class U, class O>
index 4b4469d..21132a0 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2015 - Scilab Enteprises - Antoine ELIAS
+// Copyright (C) 2016 - Scilab Enteprises - Piere-Aime AGNEL
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
@@ -31,8 +32,9 @@ assert_checkerror("sparse(a2) + a3", msprintf(msg1 + "%s", msprintf(msg2, "%sp_a
 assert_checkerror("a3 + sparse(a2)", msprintf(msg1 + "%s", msprintf(msg2, "%s_a_sp")));
 // and
 //double & double
-assert_checkerror("a3 & a2", msprintf(msg1 + "%s", msprintf(msg2, "%s_h_s")));
-assert_checkerror("a2 & a3", msprintf(msg1 + "%s", msprintf(msg2, "%s_h_s")));
+// Converted first to boolean before & operation after https://codereview.scilab.org/#/c/18387/
+assert_checkerror("a3 & a2", msprintf(msg1 + "%s", msprintf(msg2, "%b_h_b")));
+assert_checkerror("a2 & a3", msprintf(msg1 + "%s", msprintf(msg2, "%b_h_b")));
 //int & int
 assert_checkerror("int8(a3) & int8(a2)", msprintf(msg1 + "%s", msprintf(msg2, "%i_h_i")));
 assert_checkerror("int8(a2) & int8(a3)", msprintf(msg1 + "%s", msprintf(msg2, "%i_h_i")));
@@ -84,9 +86,11 @@ assert_checkerror("sparse(a2) * a3", msprintf(msg1 + "%s", msprintf(msg2, "%sp_m
 assert_checkerror("a3 * sparse(a2)", msprintf(msg1 + "%s", msprintf(msg2, "%s_m_sp")));
 // or
 //double | double
-assert_checkerror("a3 | a2", msprintf(msg1 + "%s", msprintf(msg2, "%s_g_s")));
-assert_checkerror("a2 | a3", msprintf(msg1 + "%s", msprintf(msg2, "%s_g_s")));
+// Converted first to boolean before | operation after https://codereview.scilab.org/#/c/18387/
+assert_checkerror("a3 | a2", msprintf(msg1 + "%s", msprintf(msg2, "%b_g_b")));
+assert_checkerror("a2 | a3", msprintf(msg1 + "%s", msprintf(msg2, "%b_g_b")));
 //int | int
+// Converted first to boolean before | operation after https://codereview.scilab.org/#/c/18387/
 assert_checkerror("int8(a3) | int8(a2)", msprintf(msg1 + "%s", msprintf(msg2, "%i_g_i")));
 assert_checkerror("int8(a2) | int8(a3)", msprintf(msg1 + "%s", msprintf(msg2, "%i_g_i")));
 //subtraction
index fcde0f3..3e78e2a 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2015 - Scilab Enteprises - Antoine ELIAS
+// Copyright (C) 2016 - Scilab Enteprises - Piere-Aime AGNEL
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
@@ -39,8 +40,9 @@ assert_checkerror("a3 + sparse(a2)", msprintf(msg1 + "%s", msprintf(msg2, "%s_a_
 
 // and
 //double & double
-assert_checkerror("a3 & a2", msprintf(msg1 + "%s", msprintf(msg2, "%s_h_s")));
-assert_checkerror("a2 & a3", msprintf(msg1 + "%s", msprintf(msg2, "%s_h_s")));
+// Converted first to boolean before & operation after https://codereview.scilab.org/#/c/18387/
+assert_checkerror("a3 & a2", msprintf(msg1 + "%s", msprintf(msg2, "%b_h_b")));
+assert_checkerror("a2 & a3", msprintf(msg1 + "%s", msprintf(msg2, "%b_h_b")));
 
 //int & int
 assert_checkerror("int8(a3) & int8(a2)", msprintf(msg1 + "%s", msprintf(msg2, "%i_h_i")));
@@ -110,10 +112,12 @@ assert_checkerror("a3 * sparse(a2)", msprintf(msg1 + "%s", msprintf(msg2, "%s_m_
 
 // or
 //double | double
-assert_checkerror("a3 | a2", msprintf(msg1 + "%s", msprintf(msg2, "%s_g_s")));
-assert_checkerror("a2 | a3", msprintf(msg1 + "%s", msprintf(msg2, "%s_g_s")));
+// Converted first to boolean before | operation after https://codereview.scilab.org/#/c/18387/
+assert_checkerror("a3 | a2", msprintf(msg1 + "%s", msprintf(msg2, "%b_g_b")));
+assert_checkerror("a2 | a3", msprintf(msg1 + "%s", msprintf(msg2, "%b_g_b")));
 
 //int | int
+// Converted first to boolean before | operation after https://codereview.scilab.org/#/c/18387/
 assert_checkerror("int8(a3) | int8(a2)", msprintf(msg1 + "%s", msprintf(msg2, "%i_g_i")));
 assert_checkerror("int8(a2) | int8(a3)", msprintf(msg1 + "%s", msprintf(msg2, "%i_g_i")));
 
diff --git a/scilab/modules/ast/tests/nonreg_tests/bug_14681.dia.ref b/scilab/modules/ast/tests/nonreg_tests/bug_14681.dia.ref
new file mode 100644 (file)
index 0000000..9742a1c
--- /dev/null
@@ -0,0 +1,54 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- CLI SHELL MODE -->
+// <-- Non-regression test for bug 14681 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=14681
+//
+// <-- Short Description -->
+//    Short circuited AND operation was not possible with double matrices in if and while clauses
+// Testing if
+global("bar");
+bar = 0;
+function res = foo()
+    warning("foo() should not be executed in this test");
+    global("bar");
+    bar = 1;
+    res = %t;
+endfunction
+andCond = %f;
+orCond = %t;
+if andCond && foo() then; end
+assert_checkequal(bar, 0);
+if andCond & foo() then; end
+assert_checkequal(bar, 0);
+if orCond | foo() then; end
+assert_checkequal(bar, 0);
+if orCond || foo() then; end
+assert_checkequal(bar, 0);
+andCond = 0;
+orCond = 1;
+if andCond && foo() then; end
+assert_checkequal(bar, 0);
+if andCond & foo() then; end
+assert_checkequal(bar, 0);
+if orCond | foo() then; end
+assert_checkequal(bar, 0);
+if orCond || foo() then; end
+assert_checkequal(bar, 0);
+andCond = int8(0);
+orCond = int8(1);
+if andCond && foo() then; end
+assert_checkequal(bar, 0);
+if andCond & foo() then; end
+assert_checkequal(bar, 0);
+if orCond | foo() then; end
+assert_checkequal(bar, 0);
+if orCond || foo() then; end
+assert_checkequal(bar, 0);
+clearglobal("bar");
diff --git a/scilab/modules/ast/tests/nonreg_tests/bug_14681.tst b/scilab/modules/ast/tests/nonreg_tests/bug_14681.tst
new file mode 100644 (file)
index 0000000..722158b
--- /dev/null
@@ -0,0 +1,62 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- CLI SHELL MODE -->
+
+// <-- Non-regression test for bug 14681 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=14681
+//
+// <-- Short Description -->
+//    Short circuited AND operation was not possible with double matrices in if and while clauses
+
+// Testing if
+global("bar");
+bar = 0;
+function res = foo()
+    warning("foo() should not be executed in this test");
+    global("bar");
+    bar = 1;
+    res = %t;
+endfunction
+
+andCond = %f;
+orCond = %t;
+
+if andCond && foo() then; end
+assert_checkequal(bar, 0);
+if andCond & foo() then; end
+assert_checkequal(bar, 0);
+if orCond | foo() then; end
+assert_checkequal(bar, 0);
+if orCond || foo() then; end
+assert_checkequal(bar, 0);
+
+andCond = 0;
+orCond = 1;
+if andCond && foo() then; end
+assert_checkequal(bar, 0);
+if andCond & foo() then; end
+assert_checkequal(bar, 0);
+if orCond | foo() then; end
+assert_checkequal(bar, 0);
+if orCond || foo() then; end
+assert_checkequal(bar, 0);
+
+andCond = int8(0);
+orCond = int8(1);
+if andCond && foo() then; end
+assert_checkequal(bar, 0);
+if andCond & foo() then; end
+assert_checkequal(bar, 0);
+if orCond | foo() then; end
+assert_checkequal(bar, 0);
+if orCond || foo() then; end
+assert_checkequal(bar, 0);
+
+clearglobal("bar");
index 1ca0b0d..cf7fec3 100644 (file)
@@ -370,3 +370,91 @@ if b0 & b134 then bugmes();quit;end
 if b0 & b234 then bugmes();quit;end
 if b0 & b1234 then bugmes();quit;end
 //others case returns true and we do not want to test with '=='
+A = [0 1; 1 0];
+B = [1 1; 0 0];
+spA = sparse(A);
+spB = sparse(B);
+spbA = sparse(A<>0);
+spbB = sparse(B<>0);
+iA = int8(A);
+iB = int8(B);
+cA = A + 0*%i;
+cB = B + 0*%i;
+resAandB = [%f %t; %f %f];
+sp_resAandB = sparse(resAandB);
+assert_checkequal( A & B   , resAandB );
+assert_checkequal( A & iB  , resAandB );
+assert_checkequal( iA & B  , resAandB );
+assert_checkequal( cA & B  , resAandB );
+assert_checkequal( A & cB  , resAandB );
+assert_checkequal( cA & cB , resAandB );
+assert_checkequal( A & spB     , sp_resAandB );
+assert_checkequal( spA & B     , sp_resAandB );
+assert_checkequal( A & spbB    , sp_resAandB );
+assert_checkequal( spbA & B    , sp_resAandB );
+assert_checkequal( spA & spB   , sp_resAandB );
+assert_checkequal( spA & spbB  , sp_resAandB );
+assert_checkequal( spbA & spB  , sp_resAandB );
+assert_checkequal( spbA & spbB , sp_resAandB );
+assert_checkequal( spbA & iB   , sp_resAandB );
+assert_checkequal( iA & spbB   , sp_resAandB );
+assert_checkequal( spA & iB    , sp_resAandB );
+assert_checkequal( iA & spB    , sp_resAandB );
+assert_checkequal( cA & spB    , sp_resAandB );
+assert_checkequal( spA & cB    , sp_resAandB );
+assert_checkequal( cA & spbB   , sp_resAandB );
+assert_checkequal( spbA & cB   , sp_resAandB );
+resAorB = [%t %t; %t %f];
+sp_resAorB = sparse(resAorB);
+assert_checkequal( A | B   , resAorB );
+assert_checkequal( A | iB  , resAorB );
+assert_checkequal( iA | B  , resAorB );
+assert_checkequal( A | cB  , resAorB );
+assert_checkequal( cA | B  , resAorB );
+assert_checkequal( cA | cB , resAorB );
+assert_checkequal( A | spB     , sp_resAorB );
+assert_checkequal( spA | B     , sp_resAorB );
+assert_checkequal( A | spbB    , sp_resAorB );
+assert_checkequal( spbA | B    , sp_resAorB );
+assert_checkequal( spA | spB   , sp_resAorB );
+assert_checkequal( spA | spbB  , sp_resAorB );
+assert_checkequal( spbA | spB  , sp_resAorB );
+assert_checkequal( spbA | spbB , sp_resAorB );
+assert_checkequal( spbA | iB   , sp_resAorB );
+assert_checkequal( iA | spbB   , sp_resAorB );
+assert_checkequal( spA | iB    , sp_resAorB );
+assert_checkequal( iA | spB    , sp_resAorB );
+assert_checkequal( cA | spB    , sp_resAorB );
+assert_checkequal( spA | cB    , sp_resAorB );
+assert_checkequal( cA | spbB   , sp_resAorB );
+assert_checkequal( spbA | cB   , sp_resAorB );
+// Integer manipulation
+// Integer representation
+i8_A = int8([ -1, 1; 127, -128]);
+// Integer representation of i8_A:
+// [ 1111 1111, 0000 0001 ;
+//   0111 1111, 1000 0000 ]
+i8_B = int8([-2, 0; 126, -127]);
+// Integer representation of i8_A:
+// [ 1111 1110, 0000 0000 ;
+//   0111 1110, 1000 0001 ]
+// Bitwise AND
+resIntAandB = int8([-2, 0; 126, -128]);
+resIntAorB = int8([-1, 1; 127, -127]);
+assert_checkequal( i8_A & i8_B , resIntAandB );
+assert_checkequal( i8_A | i8_B , resIntAorB );
+// Inttype promotion
+// int8 < int16 < int32 < int64
+// uint8 < uint16 < uint32 < uint64
+assert_checkequal( int16(i8_A) & i8_B  , int16(resIntAandB) );
+assert_checkequal( int32(i8_A) & i8_B  , int32(resIntAandB) );
+assert_checkequal( int64(i8_A) & i8_B  , int64(resIntAandB) );
+assert_checkequal( uint16(i8_A) & i8_B , uint16(resIntAandB) );
+assert_checkequal( uint32(i8_A) & i8_B , uint32(resIntAandB) );
+assert_checkequal( uint64(i8_A) & i8_B , uint64(resIntAandB) );
+assert_checkequal( i8_A | int16(i8_B)  , int16(resIntAorB) );
+assert_checkequal( i8_A | int32(i8_B)  , int32(resIntAorB) );
+assert_checkequal( i8_A | int64(i8_B)  , int64(resIntAorB) );
+assert_checkequal( i8_A | uint16(i8_B) , uint16(resIntAorB) );
+assert_checkequal( i8_A | uint32(i8_B) , uint32(resIntAorB) );
+assert_checkequal( i8_A | uint64(i8_B) , uint64(resIntAorB) );
index 7821a4b..1a6f5d2 100644 (file)
@@ -427,3 +427,107 @@ if b0 & b134 then pause; end
 if b0 & b234 then pause; end
 if b0 & b1234 then pause; end
 //others case returns true and we do not want to test with '=='
+
+A = [0 1; 1 0];
+B = [1 1; 0 0];
+spA = sparse(A);
+spB = sparse(B);
+spbA = sparse(A<>0);
+spbB = sparse(B<>0);
+iA = int8(A);
+iB = int8(B);
+cA = A + 0*%i;
+cB = B + 0*%i;
+
+resAandB = [%f %t; %f %f];
+sp_resAandB = sparse(resAandB);
+
+assert_checkequal( A & B   , resAandB );
+assert_checkequal( A & iB  , resAandB );
+assert_checkequal( iA & B  , resAandB );
+assert_checkequal( cA & B  , resAandB );
+assert_checkequal( A & cB  , resAandB );
+assert_checkequal( cA & cB , resAandB );
+
+assert_checkequal( A & spB     , sp_resAandB );
+assert_checkequal( spA & B     , sp_resAandB );
+assert_checkequal( A & spbB    , sp_resAandB );
+assert_checkequal( spbA & B    , sp_resAandB );
+assert_checkequal( spA & spB   , sp_resAandB );
+assert_checkequal( spA & spbB  , sp_resAandB );
+assert_checkequal( spbA & spB  , sp_resAandB );
+assert_checkequal( spbA & spbB , sp_resAandB );
+assert_checkequal( spbA & iB   , sp_resAandB );
+assert_checkequal( iA & spbB   , sp_resAandB );
+assert_checkequal( spA & iB    , sp_resAandB );
+assert_checkequal( iA & spB    , sp_resAandB );
+assert_checkequal( cA & spB    , sp_resAandB );
+assert_checkequal( spA & cB    , sp_resAandB );
+assert_checkequal( cA & spbB   , sp_resAandB );
+assert_checkequal( spbA & cB   , sp_resAandB );
+
+resAorB = [%t %t; %t %f];
+sp_resAorB = sparse(resAorB);
+
+assert_checkequal( A | B   , resAorB );
+assert_checkequal( A | iB  , resAorB );
+assert_checkequal( iA | B  , resAorB );
+assert_checkequal( A | cB  , resAorB );
+assert_checkequal( cA | B  , resAorB );
+assert_checkequal( cA | cB , resAorB );
+
+assert_checkequal( A | spB     , sp_resAorB );
+assert_checkequal( spA | B     , sp_resAorB );
+assert_checkequal( A | spbB    , sp_resAorB );
+assert_checkequal( spbA | B    , sp_resAorB );
+assert_checkequal( spA | spB   , sp_resAorB );
+assert_checkequal( spA | spbB  , sp_resAorB );
+assert_checkequal( spbA | spB  , sp_resAorB );
+assert_checkequal( spbA | spbB , sp_resAorB );
+assert_checkequal( spbA | iB   , sp_resAorB );
+assert_checkequal( iA | spbB   , sp_resAorB );
+assert_checkequal( spA | iB    , sp_resAorB );
+assert_checkequal( iA | spB    , sp_resAorB );
+assert_checkequal( cA | spB    , sp_resAorB );
+assert_checkequal( spA | cB    , sp_resAorB );
+assert_checkequal( cA | spbB   , sp_resAorB );
+assert_checkequal( spbA | cB   , sp_resAorB );
+
+// Integer manipulation
+
+// Integer representation
+i8_A = int8([ -1, 1; 127, -128]);
+// Integer representation of i8_A:
+// [ 1111 1111, 0000 0001 ;
+//   0111 1111, 1000 0000 ]
+
+i8_B = int8([-2, 0; 126, -127]);
+// Integer representation of i8_A:
+// [ 1111 1110, 0000 0000 ;
+//   0111 1110, 1000 0001 ]
+
+// Bitwise AND
+resIntAandB = int8([-2, 0; 126, -128]);
+resIntAorB = int8([-1, 1; 127, -127]);
+
+assert_checkequal( i8_A & i8_B , resIntAandB );
+assert_checkequal( i8_A | i8_B , resIntAorB );
+
+// Inttype promotion
+// int8 < int16 < int32 < int64
+// uint8 < uint16 < uint32 < uint64
+assert_checkequal( int16(i8_A) & i8_B  , int16(resIntAandB) );
+assert_checkequal( int32(i8_A) & i8_B  , int32(resIntAandB) );
+assert_checkequal( int64(i8_A) & i8_B  , int64(resIntAandB) );
+assert_checkequal( uint16(i8_A) & i8_B , uint16(resIntAandB) );
+assert_checkequal( uint32(i8_A) & i8_B , uint32(resIntAandB) );
+assert_checkequal( uint64(i8_A) & i8_B , uint64(resIntAandB) );
+
+assert_checkequal( i8_A | int16(i8_B)  , int16(resIntAorB) );
+assert_checkequal( i8_A | int32(i8_B)  , int32(resIntAorB) );
+assert_checkequal( i8_A | int64(i8_B)  , int64(resIntAorB) );
+assert_checkequal( i8_A | uint16(i8_B) , uint16(resIntAorB) );
+assert_checkequal( i8_A | uint32(i8_B) , uint32(resIntAorB) );
+assert_checkequal( i8_A | uint64(i8_B) , uint64(resIntAorB) );
+
+
index 53ef05c..6bca5a7 100644 (file)
  *
  -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="and_op" xml:lang="en">
+    
     <refnamediv>
-        <refname>&amp;</refname>
+        <refname>&amp;, &amp;&amp;</refname>
         <refpurpose>logical AND operator</refpurpose>
     </refnamediv>
+    
     <refsynopsisdiv>
         <title>Syntax</title>
-        <synopsis>A&amp;B</synopsis>
+        <para>
+            Matrix operation with full evaluation:
+        </para>
+        <synopsis>
+            full_res = A &amp; B
+            int_res = intA &amp; intB
+        </synopsis>
+        <para>
+            Short-circuited evaluation:
+        </para>
+        <synopsis>
+            short_circuit_res = A &amp;&amp; B
+            if (A &amp; B) then ... end
+            if (A &amp;&amp; B) then ... end
+            while (A &amp; B) then ... end
+            while (A &amp;&amp; B) then ... end
+        </synopsis>
     </refsynopsisdiv>
+    
+    <refsection role="parameters">
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>A</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>B</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>full_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>full_res</varname>
+                        is a boolean matrix of their common size.
+                        The result is the element-wise <link linkend="and">and</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>full_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="and">and</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                    <para>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intA</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intB</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>int_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>int_res</varname>
+                        is a matrix of integer of their common size.
+                        The result is the element-wise <link linkend="bitand">bitand</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>int_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="bitand">bitand</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
+                        integer promotion is performed according to the following rules:
+                        <itemizedlist>
+                            <listitem>
+                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
+                            </listitem>
+                            <listitem>
+                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
+                            </listitem>
+                            <listitem>
+                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
+                            </listitem>
+                        </itemizedlist>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>short_circuit_res</term>
+                <listitem>
+                    <para>
+                        boolean scalar when the operation is short-circuited.
+                    </para>
+                    <para>
+                        The short-circuit operation evaluates to false if any entry of <varname>A</varname> is false. In this case <varname>B</varname> is not evaluated.
+                    </para>
+                    <para>
+                        See <link linkend="and">and</link> for the definition of the evaluation to false depending on type and encoding.
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    
     <refsection>
         <title>Description</title>
         <para>
-            <literal>A&amp;B</literal> gives the element-wise logical
-            <literal>and</literal> of the booleans matrices <literal>A</literal> and
-            <literal>B</literal>. <literal>A</literal> and <literal>B</literal> must
+            When the right and left operands are <emphasis>not</emphasis> both of integer type, <literal>A &amp; B</literal> yields the element-wise logical
+            <literal>AND</literal> of matrices <varname>A</varname> and
+            <literal>B</literal> evaluated as matrices of boolean. <varname>A</varname> and <varname>B</varname> must
             be matrices with the same dimensions or one from them must be a single
             boolean.
+            If any operand is sparse the result of <literal>A &amp; B</literal> is sparse encoded.
+        </para>
+        <para>
+            When both operands are of integer type, <literal>A &amp; B</literal> yields the bitwise comparison between each element of <varname>A</varname> and <varname>B</varname>.
+        </para>
+        <para>
+            For <link linkend="if">if</link> and <link linkend="while">while</link> control structures or when computing <literal>A &amp;&amp; B</literal>, the left operand is evaluated prior to the right operand. If any entry in the left operand is false, the result is set to <literal>%f</literal> short-circuiting the evaluation of the right operand.
+            Otherwise, <literal>A &amp; B</literal> is computed.
         </para>
     </refsection>
+    
     <refsection>
         <title>Examples</title>
         <programlisting role="example"><![CDATA[
-[%t %t %f] & [%f %t %t]
-[%t %t %f] & %f
-[%t %t %f] & %t
+A = [0 1; 1 0];
+B = [1 1; 0 0];
+spA = sparse(A);
+spB = sparse(B);
+spbA = sparse(A<>0);
+spbB = sparse(B<>0);
+iA = int8(A);
+iB = int8(B);
+cA = A + 0*%i;
+cB = B + 0*%i;
+
+// A is evaluated as
+// [%f, %t;
+//  %t, %f]
+// B is evaluated as
+// [%t, %t;
+//  %f, %f]
+
+// & as logical operation
+A & B
+A & spB  // Result is sparse encoded
+iA & spB // Result is sparse encoded
+cA & iB
+
+// & as bitwise operation
+iA & iB
+
+i8_A = int8([ -1, 1; 127, -128]);
+// Integer representation of i8_A:
+// [ 1111 1111, 0000 0001 ;
+//   0111 1111, 1000 0000 ]
+
+i8_B = int8([-2, 0; 126, -127]);
+// Integer representation of i8_A:
+// [ 1111 1110, 0000 0000 ;
+//   0111 1110, 1000 0001 ]
+
+i8_1 & i8_B
+
+// Integer promotion
+i16_A = int16(i8_A);
+ui32_B = uint32(i8_B);
+
+i16_A & ui32_B
+
+// && as a shortcut operation
+function res = foo()
+    disp("this is executed");
+    res = %t;
+endfunction
+
+if ( %f & foo() ) then
+    // This is not executed
+end
+
+A && foo()  // A has at least one element equals to 0
+iA && foo() // therefore, foo() is not executed
+cA && foo()
+
+iA && iB // iA is evalueated as false resulting in the short-circuited operation
  ]]></programlisting>
     </refsection>
     
             <member>
                 <link linkend="or_op">or operator (|)</link>
             </member>
+            <member>
+                <link linkend="bitand">bitand</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index 4fb14fe..468752f 100644 (file)
  -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="or_op" xml:lang="en">
     <refnamediv>
-        <refname>|</refname>
+        <refname>|, ||</refname>
         <refpurpose>logical OR operator</refpurpose>
     </refnamediv>
+    
     <refsynopsisdiv>
         <title>Syntax</title>
-        <synopsis>A|B</synopsis>
+        <para>
+            Matrix operation with full evaluation:
+        </para>
+        <synopsis>
+            full_res = A | B
+            int_res = intA | intB
+        </synopsis>
+        <para>
+            Short-circuited evaluation:
+        </para>
+        <synopsis>
+            short_circuit_res = A || B
+            if (A | B) then ... end
+            if (A || B) then ... end
+            while (A | B) then ... end
+            while (A || B) then ... end
+        </synopsis>
     </refsynopsisdiv>
+    
+    <refsection role="parameters">
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>A</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>B</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>full_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>full_res</varname>
+                        is a boolean matrix of their common size.
+                        The result is the element-wise <link linkend="or">or</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>full_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="or">or</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intA</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intB</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>int_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>int_res</varname>
+                        is a matrix of integer of their common size.
+                        The result is the element-wise <link linkend="bitor">bitor</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>int_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="bitor">bitor</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
+                        integer promotion is performed according to the following rules:
+                        <itemizedlist>
+                            <listitem>
+                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
+                            </listitem>
+                            <listitem>
+                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
+                            </listitem>
+                            <listitem>
+                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
+                            </listitem>
+                        </itemizedlist>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>short_circuit_res</term>
+                <listitem>
+                    <para>
+                        boolean scalar when the operation is short-circuited.
+                    </para>
+                    <para>
+                        The short-circuit operation evaluates to true if all entries of <varname>A</varname> is true. In this case <varname>B</varname> is not evaluated.
+                    </para>
+                    <para>
+                        See <link linkend="or">or</link> for the definition of the evaluation to true depending on type and encoding.
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    
     <refsection>
         <title>Description</title>
         <para>
-            <literal>A|B</literal> gives the element-wise logical
-            <literal>or</literal> of the booleans matrices <literal>A</literal> and
-            <literal>B</literal>. <literal>A</literal> and <literal>B</literal> must
+            When the right and left operands are <emphasis>not both</emphasis> of integer type, <literal>A | B</literal> yields the element-wise logical
+            <literal>OR</literal> of matrices <varname>A</varname> and
+            <literal>B</literal> evaluated as matrices of boolean. <varname>A</varname> and <varname>B</varname> must
             be matrices with the same dimensions or one from them must be a single
             boolean.
+            If any operand is sparse the result of <literal>A | B</literal> is sparse encoded.
+        </para>
+        <para>
+            When both operands are of integer type, <literal>A | B</literal> yields the bitwise comparison between each element of <varname>A</varname> and <varname>B</varname>.
+        </para>
+        <para>
+            For <link linkend="if">if</link> and <link linkend="while">while</link> control structures or when computing <literal>A || B</literal>, the left operand is evaluated prior to the right operand. If all entries in the left operand are true, the result is set to <literal>%t</literal> short-circuiting the evaluation of the right operand.
+            Otherwise, <literal>A | B</literal> is computed.
         </para>
     </refsection>
+    
     <refsection>
         <title>Examples</title>
         <programlisting role="example"><![CDATA[ 
-[%t %t %f] | [%f %t %t]
-[%t %t %f] | %f
+A = [0 1; 1 0];
+B = [1 1; 0 0];
+spA = sparse(A);
+spB = sparse(B);
+spbA = sparse(A<>0);
+spbB = sparse(B<>0);
+iA = int8(A);
+iB = int8(B);
+cA = A + 0*%i;
+cB = B + 0*%i;
+
+// A is evaluated as
+// [%f, %t;
+//  %t, %f]
+// B is evaluated as
+// [%t, %t;
+//  %f, %f]
+
+// | as logical operation
+A | B
+A | spB  // Result is sparse encoded
+iA | spB // Result is sparse encoded
+cA | iB
+
+// | as bitwise operation
+iA | iB
+
+i8_A = int8([ -1, 1; 127, -128]);
+// Integer representation of i8_A:
+// [ 1111 1111, 0000 0001 ;
+//   0111 1111, 1000 0000 ]
+
+i8_B = int8([-2, 0; 126, -127]);
+// Integer representation of i8_A:
+// [ 1111 1110, 0000 0000 ;
+//   0111 1110, 1000 0001 ]
+
+i8_1 | i8_B
+
+// Integer promotion
+i16_A = int16(i8_A);
+ui32_B = uint32(i8_B);
+
+i16_A | ui32_B
+
+// || as a shortcut operation
+function res = foo()
+    disp("this is executed");
+    res = %t;
+endfunction
+
+if ( %t | foo() ) then
+    // foo is not executed
+end
+
+C = [1 %i; 2, 10]; // All C entries are different than 0
+if ( C || foo() ) then
+    // foo() is not executed
+end
+
  ]]></programlisting>
     </refsection>
+    
     <refsection role="see also">
         <title>See also</title>
         <simplelist type="inline">
             <member>
                 <link linkend="find">find</link>
             </member>
+            <member>
+                <link linkend="bitor">bitor</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index 734eda8..0616435 100644 (file)
 <?xml version="1.0" encoding="UTF-8"?>
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="and_op" xml:lang="fr">
     <refnamediv>
-        <refname>&amp;</refname>
-        <refpurpose>opérateur et logique</refpurpose>
+        <refname>&amp;, &amp;&amp;</refname>
+        <refpurpose>opérateur ET logique</refpurpose>
     </refnamediv>
     <refsynopsisdiv>
         <title>Séquence d'appel</title>
-        <synopsis>A&amp;B</synopsis>
+        <para>
+            Opérateur matriciel avec évaluation complète:
+        </para>
+        <synopsis>
+            full_res = A &amp; B
+            int_res = intA &amp; intB
+        </synopsis>
+        <para>
+            Évaluation court-circuitée :
+        </para>
+        <synopsis>
+            short_circuit_res = A &amp;&amp; B
+            if (A &amp; B) then ... end
+            if (A &amp;&amp; B) then ... end
+            while (A &amp; B) then ... end
+            while (A &amp;&amp; B) then ... end
+        </synopsis>
     </refsynopsisdiv>
+    
+    <refsection role="parameters">
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>A</term>
+                <listitem>
+                    <para>
+                        scalaire, vecteur, matrice ou hypermatrice de booléens (possiblement creux),
+                        d'entiers codés (de tout <link linkend="inttype">inttype</link>), de nombres réels ou complexes.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>B</term>
+                <listitem>
+                    <para>
+                        scalaire, vecteur, matrice ou hypermatrice de booléens (possiblement creux),
+                        d'entiers codés (de tout <link linkend="inttype">inttype</link>), de nombres réels ou complexes.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>full_res</term>
+                <listitem>
+                    <para>
+                        Si <varname>A</varname> et <varname>B</varname> ne sont pas des scalaires,
+                        ils doivent être de la même taille et <varname>full_res</varname> est alors une matrice
+                        de booléens de leur taille commune.
+                        Le résultat est l'opérateur <link linkend="and">and</link> logique appliqué élément
+                        par élément entre <varname>A</varname> et <varname>B</varname>.
+                    </para>
+                    <para>
+                        Si <varname>A</varname> ou <varname>B</varname> est un scalaire,
+                        <varname>full_res</varname> est une matrice de booléens
+                        de la taille de l'autre opérande.
+                        Le résultat est l'opérateur <link linkend="and">and</link> logique appliqué élément par élément
+                        entre la matrice de la plus grande taille et le scalaire.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intA</term>
+                <listitem>
+                    <para>
+                        scalaire, vecteur, matrice ou hypermatrice
+                        d'entiers codés (de tout <link linkend="inttype">inttype</link>).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intB</term>
+                <listitem>
+                    <para>
+                        scalaire, vecteur, matrice ou hypermatrice
+                        d'entiers codés (de tout <link linkend="inttype">inttype</link>).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>int_res</term>
+                <listitem>
+                    <para>
+                        Si <varname>A</varname> et <varname>B</varname> ne sont pas des scalaires,
+                        ils doivent être de la même taille et <varname>int_res</varname> est alors une matrice
+                        de booléens de leur taille commune.
+                        Le résultat est l'opérateur <link linkend="bitand">bitand</link> appliqué élément
+                        par élément entre <varname>A</varname> et <varname>B</varname>.
+                    </para>
+                    <para>
+                        Si <varname>A</varname> ou <varname>B</varname> est un scalaire,
+                        <varname>int_res</varname> est une matrice de booléens
+                        de la taille de l'autre opérande.
+                        Le résultat est l'opérateur <link linkend="bitand">bitand</link> appliqué élément par élément
+                        entre la matrice de la plus grande taille et le scalaire.
+                    </para>
+                    <para>
+                        Si les codages en entier de <varname>A</varname> et <varname>B</varname> sont différents,
+                        une promotion d'entier est opérée selon les règles suivantes :
+                        <itemizedlist>
+                            <listitem>
+                                si une des opérandes est non signée,  <varname>int_res</varname> est non signé;
+                            </listitem>
+                            <listitem>
+                                <varname>int_res</varname> a le codage entier du nombre de bits le plus grand entre le codage de <varname>A</varname> et celui de <varname>B</varname>;
+                            </listitem>
+                            <listitem>
+                                <varname>A</varname> et <varname>B</varname> sont promus pour être du même codage avant que l'opération ne soit effectuée.
+                            </listitem>
+                        </itemizedlist>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>short_circuit_res</term>
+                <listitem>
+                    <para>
+                        booléen scalaire si l'opération est court-circuitée.
+                    </para>
+                    <para>
+                        L'opération court-circuitée renvoie vrai si toutes les entrées de <varname>A</varname> sont vraies. Dans ce cas <varname>B</varname> n'est pas évaluée.
+                    </para>
+                    <para>
+                        Voir <link linkend="and">and</link> pour la définition de l'évaluation à vrai selon le type et le codage utilisé.
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    
     <refsection>
         <title>Description</title>
         <para>
-            <literal>A&amp;B</literal> renvoie la conjonction logique élément
-            par élément des matrices booléennes <literal>A</literal> et
-            <literal>B</literal> .<literal>A</literal> et <literal>B</literal> doivent
-            être des matrices de même dimensions ou l'une d'elle doit être un simple
-            booléen.
+            Quand les opérandes de gauche et de droite ne sont <emphasis>pas toutes deux</emphasis> de type entier, <literal>A &amp; B</literal> renvoie le <literal>ET</literal> logique effectué élément par élément entre les matrices <varname>A</varname> et <varname>B</varname> évaluées comme matrice de booléens.
+            <varname>A</varname> et <varname>B</varname> doivent être des matrices de même taille ou l'une d'entre elle doit être un scalaire.
+            Si une opérande est creuse, le résultat de <literal>A &amp; B</literal> est creux.
+        </para>
+        <para>
+            Quand les deux opérandes sont de type entier, <literal>A &amp; B</literal> renvoie la comparaison bit à bit de chaque élément de <varname>A</varname> et de <varname>B</varname>.
         </para>
+        <para>
+            Pour les structures de contrôle <link linkend="if">if</link> et <link linkend="while">while</link> ou quand l'on calcule <literal>A &amp;&amp; B</literal>, l'opérande de gauche est évaluée avant l'opérande de droite. Si une entrée de l'opérande de gauche est fausse, le résultat est <literal>%f</literal>, ce qui court-circuite l'évaluation de l'opérande de droite.
+            Dans les autres cas, l'on calcule <literal>A &amp; B.</literal>
+        </para>
+    </refsection>
+    <refsection>
+        <title>Exemples</title>
+        <programlisting role="example"><![CDATA[ 
+A = [0 1; 1 0];
+B = [1 1; 0 0];
+spA = sparse(A);
+spB = sparse(B);
+spbA = sparse(A<>0);
+spbB = sparse(B<>0);
+iA = int8(A);
+iB = int8(B);
+cA = A + 0*%i;
+cB = B + 0*%i;
+
+// A est évalué comme
+// [%f, %t;
+//  %t, %f]
+// B est évalué comme
+// [%t, %t;
+//  %f, %f]
+
+// & comme ET logique
+A & B
+A & spB  // Le résultat est creux
+iA & spB // Le résultat est creux
+cA & iB
+
+// & comme opération bit à bit
+iA & iB
+
+i8_A = int8([ -1, 1; 127, -128]);
+// codage entier de i8_A:
+// [ 1111 1111, 0000 0001 ;
+//   0111 1111, 1000 0000 ]
+
+i8_B = int8([-2, 0; 126, -127]);
+// codage entier i8_B:
+// [ 1111 1110, 0000 0000 ;
+//   0111 1110, 1000 0001 ]
+
+i8_1 & i8_B
+
+// Promotion d'entier
+i16_A = int16(i8_A);
+ui32_B = uint32(i8_B);
+
+i16_A & ui32_B
+
+// && comme opération court-circuitée
+function res = foo()
+    disp("ceci est exécuté");
+    res = %t;
+endfunction
+
+if ( %f & foo() ) then
+    // foo n'est pas exécuté
+end
+
+A && foo()  // Au moins une entrée de A vaut 0
+iA && foo() // alors, foo() n'est pas executée
+cA && foo()
+
+iA && iB // iA est évaluée à faux et l'opération est court-circuitée
+ ]]></programlisting>
     </refsection>
+    
     <refsection role="see also">
         <title>Voir aussi</title>
         <simplelist type="inline">
             <member>
                 <link linkend="or_op">opérateur ou (|)</link>
             </member>
+            <member>
+                <link linkend="bitand">bitand</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index 37c18c5..e03d1a8 100644 (file)
 <?xml version="1.0" encoding="UTF-8"?>
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="or_op" xml:lang="fr">
     <refnamediv>
-        <refname>|</refname>
+        <refname>|, ||</refname>
         <refpurpose>opérateur de disjonction logique</refpurpose>
     </refnamediv>
+    
     <refsynopsisdiv>
         <title>Séquence d'appel</title>
         <synopsis>A|B</synopsis>
+        <para>
+            Opérateur matriciel avec évaluation complète:
+        </para>
+        <synopsis>
+            full_res = A | B
+            int_res = intA | intB
+        </synopsis>
+        <para>
+            Évaluation court-circuitée :
+        </para>
+        <synopsis>
+            short_circuit_res = A || B
+            if (A | B) then ... end
+            if (A || B) then ... end
+            while (A | B) then ... end
+            while (A || B) then ... end
+        </synopsis>
     </refsynopsisdiv>
+    
+    <refsection role="parameters">
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>A</term>
+                <listitem>
+                    <para>
+                        scalaire, vecteur, matrice ou hypermatrice de booléens (possiblement creux),
+                        d'entiers codés (de tout <link linkend="inttype">inttype</link>), de nombres réels ou complexes.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>B</term>
+                <listitem>
+                    <para>
+                        scalaire, vecteur, matrice ou hypermatrice de booléens (possiblement creux),
+                        d'entiers codés (de tout <link linkend="inttype">inttype</link>), de nombres réels ou complexes.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>full_res</term>
+                <listitem>
+                    <para>
+                        Si <varname>A</varname> et <varname>B</varname> ne sont pas des scalaires,
+                        ils doivent être de la même taille et <varname>full_res</varname> est alors une matrice
+                        de booléens de leur taille commune.
+                        Le résultat est l'opérateur <link linkend="or">or</link> logique appliqué élément
+                        par élément entre <varname>A</varname> et <varname>B</varname>.
+                    </para>
+                    <para>
+                        Si <varname>A</varname> ou <varname>B</varname> est un scalaire,
+                        <varname>full_res</varname> est une matrice de booléens
+                        de la taille de l'autre opérande.
+                        Le résultat est l'opérateur <link linkend="or">or</link> logique appliqué élément par élément
+                        entre la matrice de la plus grande taille et le scalaire.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intA</term>
+                <listitem>
+                    <para>
+                        scalaire, vecteur, matrice ou hypermatrice
+                        d'entiers codés (de tout <link linkend="inttype">inttype</link>).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intB</term>
+                <listitem>
+                    <para>
+                        scalaire, vecteur, matrice ou hypermatrice
+                        d'entiers codés (de tout <link linkend="inttype">inttype</link>).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>int_res</term>
+                <listitem>
+                    <para>
+                        Si <varname>A</varname> et <varname>B</varname> ne sont pas des scalaires,
+                        ils doivent être de la même taille et <varname>int_res</varname> est alors une matrice
+                        de booléens de leur taille commune.
+                        Le résultat est l'opérateur <link linkend="bitor">bitor</link> appliqué élément
+                        par élément entre <varname>A</varname> et <varname>B</varname>.
+                    </para>
+                    <para>
+                        Si <varname>A</varname> ou <varname>B</varname> est un scalaire,
+                        <varname>int_res</varname> est une matrice de booléens
+                        de la taille de l'autre opérande.
+                        Le résultat est l'opérateur <link linkend="bitor">bitor</link> appliqué élément par élément
+                        entre la matrice de la plus grande taille et le scalaire.
+                    </para>
+                    <para>
+                        Si les codages en entier de <varname>A</varname> et <varname>B</varname> sont différents,
+                        une promotion d'entier est opérée selon les règles suivantes :
+                        <itemizedlist>
+                            <listitem>
+                                si une des opérandes est non signée,  <varname>int_res</varname> est non signé;
+                            </listitem>
+                            <listitem>
+                                <varname>int_res</varname> a le codage entier du nombre de bits le plus grand entre le codage de <varname>A</varname> et celui de <varname>B</varname>;
+                            </listitem>
+                            <listitem>
+                                <varname>A</varname> et <varname>B</varname> sont promus pour être du même codage avant que l'opération ne soit effectuée.
+                            </listitem>
+                        </itemizedlist>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>short_circuit_res</term>
+                <listitem>
+                    <para>
+                        booléen scalaire si l'opération est court-circuitée.
+                    </para>
+                    <para>
+                        L'opération court-circuitée renvoie vrai si toutes les entrées de <varname>A</varname> sont vraies. Dans ce cas <varname>B</varname> n'est pas évaluée.
+                    </para>
+                    <para>
+                        Voir <link linkend="or">or</link> pour la définition de l'évaluation à vrai selon le type et le codage utilisé.
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    
     <refsection>
         <title>Description</title>
         <para>
-            <literal>A|B</literal> renvoie la disjonction logique élément par
-            élément des matrices booléennes <literal>A</literal> et
-            <literal>B</literal>. <literal>A</literal> et <literal>B</literal> doivent
-            être des matrices de mêmes dimensions ou l'une d'elles doit être un simple
-            booléen.
+            Quand les opérandes de gauche et de droite ne sont <emphasis>pas toutes deux</emphasis> de type entier, <literal>A | B</literal> renvoie le <literal>OU</literal> logique effectué élément par élément entre les matrices <varname>A</varname> et <varname>B</varname> évaluées comme matrice de booléens.
+            <varname>A</varname> et <varname>B</varname> doivent être des matrices de même taille ou l'une d'entre elle doit être un scalaire.
+            Si une opérande est creuse, le résultat de <literal>A | B</literal> est creux.
+        </para>
+        <para>
+            Quand les deux opérandes sont de type entier, <literal>A | B</literal> renvoie la comparaison bit à bit de chaque élément de <varname>A</varname> et de <varname>B</varname>.
+        </para>
+        <para>
+            Pour les structures de contrôle <link linkend="if">if</link> et <link linkend="while">while</link> ou quand l'on calcule <literal>A || B</literal>, l'opérande de gauche est évaluée avant l'opérande de droite. Si toutes les entrées de l'opérande de gauche sont vraies, le résultat est <literal>%t</literal>, ce qui court-circuite l'évaluation de l'opérande de droite.
+            Dans les autres cas, l'on calcule <literal>A | B.</literal>
         </para>
     </refsection>
     <refsection>
         <title>Exemples</title>
         <programlisting role="example"><![CDATA[ 
-[%t %t %f]|[%f %t %t]
-[%t %t %f]|%f
+A = [0 1; 1 0];
+B = [1 1; 0 0];
+spA = sparse(A);
+spB = sparse(B);
+spbA = sparse(A<>0);
+spbB = sparse(B<>0);
+iA = int8(A);
+iB = int8(B);
+cA = A + 0*%i;
+cB = B + 0*%i;
+
+// A est évalué comme
+// [%f, %t;
+//  %t, %f]
+// B est évalué comme
+// [%t, %t;
+//  %f, %f]
+
+// | comme OU logique
+A | B
+A | spB  // Le résultat est creux
+iA | spB // Le résultat est creux
+cA | iB
+
+// | comme opération bit à bit
+iA | iB
+
+i8_A = int8([ -1, 1; 127, -128]);
+// codage entier de i8_A:
+// [ 1111 1111, 0000 0001 ;
+//   0111 1111, 1000 0000 ]
+
+i8_B = int8([-2, 0; 126, -127]);
+// codage entier i8_B:
+// [ 1111 1110, 0000 0000 ;
+//   0111 1110, 1000 0001 ]
+
+i8_1 | i8_B
+
+// Promotion d'entier
+i16_A = int16(i8_A);
+ui32_B = uint32(i8_B);
+
+i16_A | ui32_B
+
+// || comme opération court-circuitée
+function res = foo()
+    disp("ceci est exécuté");
+    res = %t;
+endfunction
+
+if ( %t | foo() ) then
+    // foo n'est pas exécuté
+end
+
+C = [1 %i; 2, 10]; // Toutes les entrées de C sont différentes de 0
+if ( C || foo() ) then
+    // foo() foo n'est pas exécuté
+end
+
  ]]></programlisting>
     </refsection>
+    
     <refsection role="see also">
         <title>Voir aussi</title>
         <simplelist type="inline">
             <member>
                 <link linkend="find">find</link>
             </member>
+            <member>
+                <link linkend="bitor">bitor</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index e3a6349..9e4d2a1 100644 (file)
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="and_op" xml:lang="ja">
     
     <refnamediv>
-        
-        <refname>&amp;</refname>
-        
+        <refname>&amp;, &amp;&amp;</refname>
         <refpurpose>論理積演算子</refpurpose>
-        
     </refnamediv>
     
     <refsynopsisdiv>
-        
         <title>呼び出し手順</title>
-        
         <synopsis>A&amp;B</synopsis>
-        
     </refsynopsisdiv>
-    
     <refsection>
-        
         <title>説明</title>
-        
         <para>
-            
-            <literal>A&amp;B</literal> は,
-            
-            論理値行列 <literal>A</literal>および<literal>B</literal>の
-            
-            要素毎の論理 <literal>and</literal>です.
-            
-            <literal>A</literal> および <literal>B</literal> は
-            
-            同じ次元を有する行列または
-            
-            どちらかが単一の論理値である必要があります.
-            
+            Matrix operation with full evaluation:
+        </para>
+        <synopsis>
+            full_res = A &amp; B
+            int_res = intA &amp; intB
+        </synopsis>
+        <para>
+            Short-circuited evaluation:
         </para>
-        
+        <synopsis>
+            short_circuit_res = A &amp;&amp; B
+            if (A &amp; B) then ... end
+            if (A &amp;&amp; B) then ... end
+            while (A &amp; B) then ... end
+            while (A &amp;&amp; B) then ... end
+        </synopsis>
+    </refsection>
+    
+    <refsection role="parameters">
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>A</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>B</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>full_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>full_res</varname>
+                        is a boolean matrix of their common size.
+                        The result is the element-wise <link linkend="and">and</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>full_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="and">and</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                    <para>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intA</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intB</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>int_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>int_res</varname>
+                        is a matrix of integer of their common size.
+                        The result is the element-wise <link linkend="bitand">bitand</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>int_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="bitand">bitand</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
+                        integer promotion is performed according to the following rules:
+                        <itemizedlist>
+                            <listitem>
+                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
+                            </listitem>
+                            <listitem>
+                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
+                            </listitem>
+                            <listitem>
+                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
+                            </listitem>
+                        </itemizedlist>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>short_circuit_res</term>
+                <listitem>
+                    <para>
+                        boolean scalar when the operation is short-circuited.
+                    </para>
+                    <para>
+                        The short-circuit operation evaluates to false if any entry of <varname>A</varname> is false. In this case <varname>B</varname> is not evaluated.
+                    </para>
+                    <para>
+                        See <link linkend="and">and</link> for the definition of the evaluation to false depending on type and encoding.
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
     </refsection>
     
     <refsection>
-        
         <title>例</title>
-        
         <programlisting role="example"><![CDATA[
-[%t %t %f] & [%f %t %t]
-[%t %t %f] & %f
-[%t %t %f] & %t
+A = [0 1; 1 0];
+B = [1 1; 0 0];
+spA = sparse(A);
+spB = sparse(B);
+spbA = sparse(A<>0);
+spbB = sparse(B<>0);
+iA = int8(A);
+iB = int8(B);
+cA = A + 0*%i;
+cB = B + 0*%i;
+
+// A is evaluated as
+// [%f, %t;
+//  %t, %f]
+// B is evaluated as
+// [%t, %t;
+//  %f, %f]
+
+// & as logical operation
+A & B
+A & spB  // Result is sparse encoded
+iA & spB // Result is sparse encoded
+cA & iB
+
+// & as bitwise operation
+iA & iB
+
+i8_A = int8([ -1, 1; 127, -128]);
+// Integer representation of i8_A:
+// [ 1111 1111, 0000 0001 ;
+//   0111 1111, 1000 0000 ]
+
+i8_B = int8([-2, 0; 126, -127]);
+// Integer representation of i8_A:
+// [ 1111 1110, 0000 0000 ;
+//   0111 1110, 1000 0001 ]
+
+i8_1 & i8_B
+
+// Integer promotion
+i16_A = int16(i8_A);
+ui32_B = uint32(i8_B);
+
+i16_A & ui32_B
+
+// && as a shortcut operation
+function res = foo()
+    disp("this is executed");
+    res = %t;
+endfunction
+
+if ( %f & foo() ) then
+    // This is not executed
+end
+
+A && foo()  // A has at least one element equals to 0
+iA && foo() // therefore, foo() is not executed
+cA && foo()
+
+iA && iB // iA is evalueated as false resulting in the short-circuited operation
  ]]></programlisting>
-        
     </refsection>
     
     <refsection role="see also">
-        
         <title>参照</title>
-        
         <simplelist type="inline">
-            
             <member>
-                
                 <link linkend="not">not</link>
-                
             </member>
-            
             <member>
-                
                 <link linkend="and">and</link>
-                
             </member>
-            
             <member>
-                
                 <link linkend="or_op">or operator (|)</link>
-                
             </member>
-            
+            <member>
+                <link linkend="bitand">bitand</link>
+            </member>
         </simplelist>
-        
     </refsection>
-    
 </refentry>
 
index 0ec4072..b04752c 100644 (file)
  -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="or_op" xml:lang="ja">
     <refnamediv>
-        <refname>|</refname>
+        <refname>|, ||</refname>
         <refpurpose>論理和演算子</refpurpose>
     </refnamediv>
+    
     <refsynopsisdiv>
         <title>呼び出し手順</title>
-        <synopsis>A|B</synopsis>
+        <para>
+            Matrix operation with full evaluation:
+        </para>
+        <synopsis>
+            full_res = A | B
+            int_res = intA | intB
+        </synopsis>
+        <para>
+            Short-circuited evaluation:
+        </para>
+        <synopsis>
+            short_circuit_res = A || B
+            if (A | B) then ... end
+            if (A || B) then ... end
+            while (A | B) then ... end
+            while (A || B) then ... end
+        </synopsis>
     </refsynopsisdiv>
+    
+    <refsection role="parameters">
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>A</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>B</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>full_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>full_res</varname>
+                        is a boolean matrix of their common size.
+                        The result is the element-wise <link linkend="or">or</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>full_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="or">or</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intA</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intB</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>int_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>int_res</varname>
+                        is a matrix of integer of their common size.
+                        The result is the element-wise <link linkend="bitor">bitor</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>int_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="bitor">bitor</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
+                        integer promotion is performed according to the following rules:
+                        <itemizedlist>
+                            <listitem>
+                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
+                            </listitem>
+                            <listitem>
+                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
+                            </listitem>
+                            <listitem>
+                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
+                            </listitem>
+                        </itemizedlist>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>short_circuit_res</term>
+                <listitem>
+                    <para>
+                        boolean scalar when the operation is short-circuited.
+                    </para>
+                    <para>
+                        The short-circuit operation evaluates to true if all entries of <varname>A</varname> is true. In this case <varname>B</varname> is not evaluated.
+                    </para>
+                    <para>
+                        See <link linkend="or">or</link> for the definition of the evaluation to true depending on type and encoding.
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    
     <refsection>
         <title>説明</title>
         <para>
-            <literal>A|B</literal> は論理値行列<literal>A</literal> および
-            <literal>B</literal>の要素毎の論理和を出力します.
-            <literal>A</literal> および <literal>B</literal> は
-            同じ次元の行列または片方が論理値スカラーである必要があります.
+            When the right and left operands are <emphasis>not both</emphasis> of integer type, <literal>A | B</literal> yields the element-wise logical
+            <literal>OR</literal> of matrices <varname>A</varname> and
+            <literal>B</literal> evaluated as matrices of boolean. <varname>A</varname> and <varname>B</varname> must
+            be matrices with the same dimensions or one from them must be a single
+            boolean.
+            If any operand is sparse the result of <literal>A | B</literal> is sparse encoded.
+        </para>
+        <para>
+            When both operands are of integer type, <literal>A | B</literal> yields the bitwise comparison between each element of <varname>A</varname> and <varname>B</varname>.
+        </para>
+        <para>
+            For <link linkend="if">if</link> and <link linkend="while">while</link> control structures or when computing <literal>A || B</literal>, the left operand is evaluated prior to the right operand. If all entries in the left operand are true, the result is set to <literal>%t</literal> short-circuiting the evaluation of the right operand.
+            Otherwise, <literal>A | B</literal> is computed.
         </para>
     </refsection>
+    
     <refsection>
         <title>例</title>
         <programlisting role="example"><![CDATA[ 
-[%t %t %f] | [%f %t %t]
-[%t %t %f] | %f
+A = [0 1; 1 0];
+B = [1 1; 0 0];
+spA = sparse(A);
+spB = sparse(B);
+spbA = sparse(A<>0);
+spbB = sparse(B<>0);
+iA = int8(A);
+iB = int8(B);
+cA = A + 0*%i;
+cB = B + 0*%i;
+
+// A is evaluated as
+// [%f, %t;
+//  %t, %f]
+// B is evaluated as
+// [%t, %t;
+//  %f, %f]
+
+// | as logical operation
+A | B
+A | spB  // Result is sparse encoded
+iA | spB // Result is sparse encoded
+cA | iB
+
+// | as bitwise operation
+iA | iB
+
+i8_A = int8([ -1, 1; 127, -128]);
+// Integer representation of i8_A:
+// [ 1111 1111, 0000 0001 ;
+//   0111 1111, 1000 0000 ]
+
+i8_B = int8([-2, 0; 126, -127]);
+// Integer representation of i8_A:
+// [ 1111 1110, 0000 0000 ;
+//   0111 1110, 1000 0001 ]
+
+i8_1 | i8_B
+
+// Integer promotion
+i16_A = int16(i8_A);
+ui32_B = uint32(i8_B);
+
+i16_A | ui32_B
+
+// || as a shortcut operation
+function res = foo()
+    disp("this is executed");
+    res = %t;
+endfunction
+
+if ( %t | foo() ) then
+    // foo is not executed
+end
+
+C = [1 %i; 2, 10]; // All C entries are different than 0
+if ( C || foo() ) then
+    // foo() is not executed
+end
  ]]></programlisting>
     </refsection>
+    
     <refsection role="see also">
         <title>参照</title>
         <simplelist type="inline">
             <member>
                 <link linkend="find">find</link>
             </member>
+            <member>
+                <link linkend="bitor">bitor</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index c6a9598..8fcb2e4 100644 (file)
  -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="and_op" xml:lang="ru">
     <refnamediv>
-        <refname>&amp;</refname>
+        <refname>&amp;, &amp;&amp;</refname>
         <refpurpose>оператор логического И</refpurpose>
     </refnamediv>
+    
     <refsynopsisdiv>
         <title>Синтаксис</title>
-        <synopsis>A&amp;B</synopsis>
+        <para>
+            Matrix operation with full evaluation:
+        </para>
+        <synopsis>
+            full_res = A &amp; B
+            int_res = intA &amp; intB
+        </synopsis>
+        <para>
+            Short-circuited evaluation:
+        </para>
+        <synopsis>
+            short_circuit_res = A &amp;&amp; B
+            if (A &amp; B) then ... end
+            if (A &amp;&amp; B) then ... end
+            while (A &amp; B) then ... end
+            while (A &amp;&amp; B) then ... end
+        </synopsis>
     </refsynopsisdiv>
+    
+    <refsection role="parameters">
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>A</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>B</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>full_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>full_res</varname>
+                        is a boolean matrix of their common size.
+                        The result is the element-wise <link linkend="and">and</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>full_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="and">and</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                    <para>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intA</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intB</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>int_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>int_res</varname>
+                        is a matrix of integer of their common size.
+                        The result is the element-wise <link linkend="bitand">bitand</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>int_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="bitand">bitand</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
+                        integer promotion is performed according to the following rules:
+                        <itemizedlist>
+                            <listitem>
+                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
+                            </listitem>
+                            <listitem>
+                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
+                            </listitem>
+                            <listitem>
+                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
+                            </listitem>
+                        </itemizedlist>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>short_circuit_res</term>
+                <listitem>
+                    <para>
+                        boolean scalar when the operation is short-circuited.
+                    </para>
+                    <para>
+                        The short-circuit operation evaluates to false if any entry of <varname>A</varname> is false. In this case <varname>B</varname> is not evaluated.
+                    </para>
+                    <para>
+                        See <link linkend="and">and</link> for the definition of the evaluation to false depending on type and encoding.
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    
     <refsection>
         <title>Описание</title>
         <para>
-            <literal>A&amp;B</literal> даёт поэлементное логическое
-            <literal>И</literal> матриц логических значений <literal>A</literal> и
-            <literal>B</literal>. <literal>A</literal> и <literal>B</literal> должны быть 
-            матрицами одинаковых размеров или одна из них должна быть логическим скаляром.
+            When the right and left operands are <emphasis>not</emphasis> both of integer type, <literal>A &amp; B</literal> yields the element-wise logical
+            <literal>AND</literal> of matrices <varname>A</varname> and
+            <literal>B</literal> evaluated as matrices of boolean. <varname>A</varname> and <varname>B</varname> must
+            be matrices with the same dimensions or one from them must be a single
+            boolean.
+            If any operand is sparse the result of <literal>A &amp; B</literal> is sparse encoded.
+        </para>
+        <para>
+            When both operands are of integer type, <literal>A &amp; B</literal> yields the bitwise comparison between each element of <varname>A</varname> and <varname>B</varname>.
         </para>
+        <para>
+            For <link linkend="if">if</link> and <link linkend="while">while</link> control structures or when computing <literal>A &amp;&amp; B</literal>, the left operand is evaluated prior to the right operand. If any entry in the left operand is false, the result is set to <literal>%f</literal> short-circuiting the evaluation of the right operand.
+            Otherwise, <literal>A &amp; B</literal> is computed.
+        </para>
+    </refsection>
+    
+    <refsection>
+        <title>Examples</title>
+        <programlisting role="example"><![CDATA[
+A = [0 1; 1 0];
+B = [1 1; 0 0];
+spA = sparse(A);
+spB = sparse(B);
+spbA = sparse(A<>0);
+spbB = sparse(B<>0);
+iA = int8(A);
+iB = int8(B);
+cA = A + 0*%i;
+cB = B + 0*%i;
+
+// A is evaluated as
+// [%f, %t;
+//  %t, %f]
+// B is evaluated as
+// [%t, %t;
+//  %f, %f]
+
+// & as logical operation
+A & B
+A & spB  // Result is sparse encoded
+iA & spB // Result is sparse encoded
+cA & iB
+
+// & as bitwise operation
+iA & iB
+
+i8_A = int8([ -1, 1; 127, -128]);
+// Integer representation of i8_A:
+// [ 1111 1111, 0000 0001 ;
+//   0111 1111, 1000 0000 ]
+
+i8_B = int8([-2, 0; 126, -127]);
+// Integer representation of i8_A:
+// [ 1111 1110, 0000 0000 ;
+//   0111 1110, 1000 0001 ]
+
+i8_1 & i8_B
+
+// Integer promotion
+i16_A = int16(i8_A);
+ui32_B = uint32(i8_B);
+
+i16_A & ui32_B
+
+// && as a shortcut operation
+function res = foo()
+    disp("this is executed");
+    res = %t;
+endfunction
+
+if ( %f & foo() ) then
+    // This is not executed
+end
+
+A && foo()  // A has at least one element equals to 0
+iA && foo() // therefore, foo() is not executed
+cA && foo()
+
+iA && iB // iA is evalueated as false resulting in the short-circuited operation
+ ]]></programlisting>
     </refsection>
+    
     <refsection role="see also">
         <title>Смотрите также</title>
         <simplelist type="inline">
             <member>
                 <link linkend="or_op">or operator (|)</link>
             </member>
+            <member>
+                <link linkend="bitand">bitand</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index a5eb86b..64ed3dc 100644 (file)
  -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="or_op" xml:lang="ru">
     <refnamediv>
-        <refname>|</refname>
+        <refname>|, ||</refname>
         <refpurpose>оператор логического ИЛИ</refpurpose>
     </refnamediv>
+    
     <refsynopsisdiv>
         <title>Синтаксис</title>
-        <synopsis>A|B</synopsis>
+        <para>
+            Matrix operation with full evaluation:
+        </para>
+        <synopsis>
+            full_res = A | B
+            int_res = intA | intB
+        </synopsis>
+        <para>
+            Short-circuited evaluation:
+        </para>
+        <synopsis>
+            short_circuit_res = A || B
+            if (A | B) then ... end
+            if (A || B) then ... end
+            while (A | B) then ... end
+            while (A || B) then ... end
+        </synopsis>
     </refsynopsisdiv>
+    
+    <refsection role="parameters">
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>A</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>B</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
+                        encoded integers (of any
+                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>full_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>full_res</varname>
+                        is a boolean matrix of their common size.
+                        The result is the element-wise <link linkend="or">or</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>full_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="or">or</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intA</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>intB</term>
+                <listitem>
+                    <para>
+                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
+                        <link linkend="inttype">inttype</link>).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>int_res</term>
+                <listitem>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are not scalar,
+                        they must be of the same size and <varname>int_res</varname>
+                        is a matrix of integer of their common size.
+                        The result is the element-wise <link linkend="bitor">bitor</link> operation between <varname>A</varname> and <varname>B</varname>.
+                    </para>
+                    <para>
+                        If <varname>A</varname> or <varname>B</varname> is a scalar,
+                        <varname>int_res</varname> is a boolean matrix of the size
+                        of the other operand.
+                        The result is the element-wise <link linkend="bitor">bitor</link> operation between the matrix of the greater size and the scalar.
+                    </para>
+                    <para>
+                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
+                        integer promotion is performed according to the following rules:
+                        <itemizedlist>
+                            <listitem>
+                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
+                            </listitem>
+                            <listitem>
+                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
+                            </listitem>
+                            <listitem>
+                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
+                            </listitem>
+                        </itemizedlist>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>short_circuit_res</term>
+                <listitem>
+                    <para>
+                        boolean scalar when the operation is short-circuited.
+                    </para>
+                    <para>
+                        The short-circuit operation evaluates to true if all entries of <varname>A</varname> is true. In this case <varname>B</varname> is not evaluated.
+                    </para>
+                    <para>
+                        See <link linkend="or">or</link> for the definition of the evaluation to true depending on type and encoding.
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    
     <refsection>
         <title>Описание</title>
         <para>
-            <literal>A|B</literal> даёт поэлементное логическое ИЛИ матриц логических
-            значений <literal>A</literal> и <literal>B</literal>. <literal>A</literal> 
-            и <literal>B</literal> должны быть матрицами одинакового размера, либо 
-            одна из них должна быть логическим скаляром.
+            When the right and left operands are <emphasis>not both</emphasis> of integer type, <literal>A | B</literal> yields the element-wise logical
+            <literal>OR</literal> of matrices <varname>A</varname> and
+            <literal>B</literal> evaluated as matrices of boolean. <varname>A</varname> and <varname>B</varname> must
+            be matrices with the same dimensions or one from them must be a single
+            boolean.
+            If any operand is sparse the result of <literal>A | B</literal> is sparse encoded.
+        </para>
+        <para>
+            When both operands are of integer type, <literal>A | B</literal> yields the bitwise comparison between each element of <varname>A</varname> and <varname>B</varname>.
+        </para>
+        <para>
+            For <link linkend="if">if</link> and <link linkend="while">while</link> control structures or when computing <literal>A || B</literal>, the left operand is evaluated prior to the right operand. If all entries in the left operand are true, the result is set to <literal>%t</literal> short-circuiting the evaluation of the right operand.
+            Otherwise, <literal>A | B</literal> is computed.
         </para>
     </refsection>
+    
     <refsection>
         <title>Примеры</title>
         <programlisting role="example"><![CDATA[ 
-[%t %t %f] | [%f %t %t]
-[%t %t %f] | %f
+A = [0 1; 1 0];
+B = [1 1; 0 0];
+spA = sparse(A);
+spB = sparse(B);
+spbA = sparse(A<>0);
+spbB = sparse(B<>0);
+iA = int8(A);
+iB = int8(B);
+cA = A + 0*%i;
+cB = B + 0*%i;
+
+// A is evaluated as
+// [%f, %t;
+//  %t, %f]
+// B is evaluated as
+// [%t, %t;
+//  %f, %f]
+
+// | as logical operation
+A | B
+A | spB  // Result is sparse encoded
+iA | spB // Result is sparse encoded
+cA | iB
+
+// | as bitwise operation
+iA | iB
+
+i8_A = int8([ -1, 1; 127, -128]);
+// Integer representation of i8_A:
+// [ 1111 1111, 0000 0001 ;
+//   0111 1111, 1000 0000 ]
+
+i8_B = int8([-2, 0; 126, -127]);
+// Integer representation of i8_A:
+// [ 1111 1110, 0000 0000 ;
+//   0111 1110, 1000 0001 ]
+
+i8_1 | i8_B
+
+// Integer promotion
+i16_A = int16(i8_A);
+ui32_B = uint32(i8_B);
+
+i16_A | ui32_B
+
+// || as a shortcut operation
+function res = foo()
+    disp("this is executed");
+    res = %t;
+endfunction
+
+if ( %t | foo() ) then
+    // foo is not executed
+end
+
+C = [1 %i; 2, 10]; // All C entries are different than 0
+if ( C || foo() ) then
+    // foo() is not executed
+end
+
  ]]></programlisting>
     </refsection>
+    
     <refsection role="see also">
         <title>Смотрите также</title>
         <simplelist type="inline">
             <member>
                 <link linkend="find">find</link>
             </member>
+            <member>
+                <link linkend="bitor">bitor</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
similarity index 81%
rename from scilab/modules/overloading/macros/%s_h_b.sci
rename to scilab/modules/overloading/macros/%b_g_i.sci
index 654bfac..d9d4b9b 100644 (file)
@@ -2,6 +2,7 @@
 // Copyright (C) INRIA
 //
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
 //
 // This file is hereby licensed under the terms of the GNU GPL v2.0,
 // pursuant to article 5.3.4 of the CeCILL v.2.1.
@@ -10,7 +11,6 @@
 // For more information, see the COPYING file which you should have received
 // along with this program.
 
-function r=%s_h_b(a,b)
-    // r=a&b
-    r=(a<>0)&b
+function res=%b_g_i(b1,i2)
+    res = (i2<>0) | b1;
 endfunction
diff --git a/scilab/modules/overloading/macros/%b_g_sp.sci b/scilab/modules/overloading/macros/%b_g_sp.sci
new file mode 100644 (file)
index 0000000..cfe6ee7
--- /dev/null
@@ -0,0 +1,17 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%b_g_sp(b1, sp2)
+    // Sparse matrix with scalar boolean special case
+    res = b1 | (sp2<>0);
+endfunction
diff --git a/scilab/modules/overloading/macros/%b_h_i.sci b/scilab/modules/overloading/macros/%b_h_i.sci
new file mode 100644 (file)
index 0000000..cd6fe80
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%b_h_i(b1,i2)
+    res = generic_s_h_s(b1,i2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%b_h_sp.sci b/scilab/modules/overloading/macros/%b_h_sp.sci
new file mode 100644 (file)
index 0000000..4f81404
--- /dev/null
@@ -0,0 +1,17 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%b_h_sp(b1, sp2)
+    // Sparse matrix with scalar boolean special case
+    res = b1 & (sp2<>0);
+endfunction
diff --git a/scilab/modules/overloading/macros/%hm_g_hm.sci b/scilab/modules/overloading/macros/%hm_g_hm.sci
deleted file mode 100644 (file)
index 6dcd4b7..0000000
+++ /dev/null
@@ -1,30 +0,0 @@
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) Bruno Pincon
-//
-// Copyright (C) 2012 - 2016 - Scilab Enterprises
-//
-// This file is hereby licensed under the terms of the GNU GPL v2.0,
-// pursuant to article 5.3.4 of the CeCILL v.2.1.
-// This file was originally licensed under the terms of the CeCILL v2.1,
-// and continues to be available under such terms.
-// For more information, see the COPYING file which you should have received
-// along with this program.
-
-function r=%hm_g_hm(a,b)
-    // define the operation a | b for boolean hypermatrices a and b
-    // a | b is defined if a and b are boolean hypermatrices
-    //                  and if a and b have the same dimensions
-    //                      or if one have only one element
-    if type(a.entries) ~= 4 | type(b.entries) ~= 4 then
-        error(msprintf(_("%s: Operand is not a boolean hypermatrix.\n"),"%hm_g_hm"));
-    end
-    if and(a.dims==b.dims) then
-        r=hypermat(a.dims,a.entries | b.entries)
-    elseif prod(a.dims) == 1 then
-        r=hypermat(b.dims,a.entries | b.entries)
-    elseif prod(b.dims) == 1 then
-        r=hypermat(a.dims,a.entries | b.entries)
-    else
-        error(msprintf(_("%s: Incompatible operand dimensions.\n"),"%hm_g_hm"));
-    end
-endfunction
diff --git a/scilab/modules/overloading/macros/%hm_h_hm.sci b/scilab/modules/overloading/macros/%hm_h_hm.sci
deleted file mode 100644 (file)
index bd9fda2..0000000
+++ /dev/null
@@ -1,31 +0,0 @@
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) Bruno Pincon
-//
-// Copyright (C) 2012 - 2016 - Scilab Enterprises
-//
-// This file is hereby licensed under the terms of the GNU GPL v2.0,
-// pursuant to article 5.3.4 of the CeCILL v.2.1.
-// This file was originally licensed under the terms of the CeCILL v2.1,
-// and continues to be available under such terms.
-// For more information, see the COPYING file which you should have received
-// along with this program.
-
-
-function r=%hm_h_hm(a,b)
-    // define the operation a & b for boolean hypermatrices a and b
-    // a & b is defined if a and b are boolean hypermatrices
-    //                  and if a and b have the same dimensions
-    //                      or if one have only one element
-    if type(a.entries) ~= 4 | type(b.entries) ~= 4 then
-        error(msprintf(_("%s: Wrong type for input argument(s): hypermatrix expected.\n"),"%hm_h_hm"));
-    end
-    if and(a.dims==b.dims) then
-        r=hypermat(a.dims,a.entries & b.entries)
-    elseif prod(a.dims) == 1 then
-        r=hypermat(b.dims,a.entries & b.entries)
-    elseif prod(b.dims) == 1 then
-        r=hypermat(a.dims,a.entries & b.entries)
-    else
-        error(msprintf(_("%s: Incompatible operand dimensions.\n"),"%hm_h_hm"));
-    end
-endfunction
diff --git a/scilab/modules/overloading/macros/%i_g_b.sci b/scilab/modules/overloading/macros/%i_g_b.sci
new file mode 100644 (file)
index 0000000..abffcf7
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%i_g_b(i1,b2)
+    res = (i1<>0) | b2;
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_g_s.sci b/scilab/modules/overloading/macros/%i_g_s.sci
new file mode 100644 (file)
index 0000000..e910df3
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%i_g_s(i1,s2)
+    res = (i1 <> 0) | (s2 <> 0);
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_g_sp.sci b/scilab/modules/overloading/macros/%i_g_sp.sci
new file mode 100644 (file)
index 0000000..499fb62
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%i_g_sp(i1,sp2)
+    res = generic_s_g_s(i1, sp2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_g_spb.sci b/scilab/modules/overloading/macros/%i_g_spb.sci
new file mode 100644 (file)
index 0000000..bb36356
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%i_g_spb(i1,spb2)
+    res = (i1 <> 0) | spb2;
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_h_b.sci b/scilab/modules/overloading/macros/%i_h_b.sci
new file mode 100644 (file)
index 0000000..66b44c6
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%i_h_b(i1,b2)
+    res = generic_s_h_s(i1, b2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_h_s.sci b/scilab/modules/overloading/macros/%i_h_s.sci
new file mode 100644 (file)
index 0000000..3c0121f
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%i_h_s(i1,s2)
+    res = generic_s_h_s(i1, s2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_h_sp.sci b/scilab/modules/overloading/macros/%i_h_sp.sci
new file mode 100644 (file)
index 0000000..d1033ad
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%i_h_sp(i1,sp2)
+    res = generic_s_h_s(i1, sp2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_h_spb.sci b/scilab/modules/overloading/macros/%i_h_spb.sci
new file mode 100644 (file)
index 0000000..fcc48d0
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%i_h_spb(i1,spb2)
+    res = (i1 <> 0) & spb2;
+endfunction
diff --git a/scilab/modules/overloading/macros/%s_g_i.sci b/scilab/modules/overloading/macros/%s_g_i.sci
new file mode 100644 (file)
index 0000000..50e9e4f
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%s_g_i(s1,i2)
+    res = (s1 <> 0) | (i2 <> 0);
+endfunction
diff --git a/scilab/modules/overloading/macros/%s_g_s.sci b/scilab/modules/overloading/macros/%s_g_s.sci
new file mode 100644 (file)
index 0000000..3b986b3
--- /dev/null
@@ -0,0 +1,17 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%s_g_s(s1,s2)
+    // Logical operand on complex numbers
+    res = (s1<>0) | (s2<>0);
+endfunction
diff --git a/scilab/modules/overloading/macros/%s_g_sp.sci b/scilab/modules/overloading/macros/%s_g_sp.sci
new file mode 100644 (file)
index 0000000..97ae43f
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%s_g_sp(s1, sp2)
+    res = generic_s_g_s(s1, sp2);
+endfunction
@@ -2,6 +2,7 @@
 // Copyright (C) INRIA
 //
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
 //
 // This file is hereby licensed under the terms of the GNU GPL v2.0,
 // pursuant to article 5.3.4 of the CeCILL v.2.1.
 // For more information, see the COPYING file which you should have received
 // along with this program.
 
-function r=%spb_h_spb(a,b)
-    //  perform logical elementwise and a&b where a and b are boolean sparse
-    //  matrices
-
-    if prod(size(a))==1 then
-        if full(a) then
-            r=b
-        else
-            r=sparse([],[],size(b))<>0
-        end
-    elseif prod(size(b))==1  then
-        if full(b) then
-            r=a
-        else
-            r=sparse([],[],size(a))<>0
-        end
-    else
-        r=a&b
-    end
+function res=%s_g_spb(s1, spb2)
+    res = (s1 <> 0) | spb2;
 endfunction
+
diff --git a/scilab/modules/overloading/macros/%s_h_i.sci b/scilab/modules/overloading/macros/%s_h_i.sci
new file mode 100644 (file)
index 0000000..3b6e0b7
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%s_h_i(s1,i2)
+    res = generic_s_h_s(s1, i2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%s_h_s.sci b/scilab/modules/overloading/macros/%s_h_s.sci
new file mode 100644 (file)
index 0000000..7b7ef39
--- /dev/null
@@ -0,0 +1,17 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%s_h_s(s1,s2)
+    // Logical operand on complex numbers
+    res = (s1<>0) & (s2<>0);
+endfunction
diff --git a/scilab/modules/overloading/macros/%s_h_sp.sci b/scilab/modules/overloading/macros/%s_h_sp.sci
new file mode 100644 (file)
index 0000000..ef33255
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%s_h_sp(s1, sp2)
+    res = generic_s_h_s(s1, sp2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%s_h_spb.sci b/scilab/modules/overloading/macros/%s_h_spb.sci
new file mode 100644 (file)
index 0000000..881443b
--- /dev/null
@@ -0,0 +1,17 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%s_h_spb(s1, spb2)
+    res = (s1 <> 0) & spb2;
+endfunction
+
diff --git a/scilab/modules/overloading/macros/%sp_g_b.sci b/scilab/modules/overloading/macros/%sp_g_b.sci
new file mode 100644 (file)
index 0000000..12d8278
--- /dev/null
@@ -0,0 +1,17 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%sp_g_b(sp1, b2)
+    // Sparse matrix with scalar boolean special case
+    res = (sp1<>0) | b2;
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_g_i.sci b/scilab/modules/overloading/macros/%sp_g_i.sci
new file mode 100644 (file)
index 0000000..208cac4
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%sp_g_i(sp1,i2)
+    res = generic_s_g_s(sp1,i2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_g_s.sci b/scilab/modules/overloading/macros/%sp_g_s.sci
new file mode 100644 (file)
index 0000000..264081e
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%sp_g_s(sp1, s2)
+    res = generic_s_g_s(sp1, s2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_g_sp.sci b/scilab/modules/overloading/macros/%sp_g_sp.sci
new file mode 100644 (file)
index 0000000..b517e19
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%sp_g_sp(sp1,sp2)
+    res = generic_s_g_s(sp1,sp2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_g_spb.sci b/scilab/modules/overloading/macros/%sp_g_spb.sci
new file mode 100644 (file)
index 0000000..b859bb9
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%sp_g_spb(sp1,spb2)
+    res = (sp1<>0)  |  spb2;
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_h_b.sci b/scilab/modules/overloading/macros/%sp_h_b.sci
new file mode 100644 (file)
index 0000000..4271b1c
--- /dev/null
@@ -0,0 +1,17 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%sp_h_b(sp1, b2)
+    // Sparse matrix with scalar boolean special case
+    res = (sp1<>0) & b2;
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_h_i.sci b/scilab/modules/overloading/macros/%sp_h_i.sci
new file mode 100644 (file)
index 0000000..378573e
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%sp_h_i(sp1,i2)
+    res = generic_s_h_s(sp1,i2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_h_s.sci b/scilab/modules/overloading/macros/%sp_h_s.sci
new file mode 100644 (file)
index 0000000..7eb6eae
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%sp_h_s(sp1, s2)
+    res = generic_s_h_s(sp1, s2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_h_sp.sci b/scilab/modules/overloading/macros/%sp_h_sp.sci
new file mode 100644 (file)
index 0000000..429f82d
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%sp_h_sp(sp1,sp2)
+    res = generic_s_h_s(sp1,sp2);
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_h_spb.sci b/scilab/modules/overloading/macros/%sp_h_spb.sci
new file mode 100644 (file)
index 0000000..c05dd59
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%sp_h_spb(sp1,spb2)
+    res = (sp1<>0)  &  spb2;
+endfunction
diff --git a/scilab/modules/overloading/macros/%spb_g_i.sci b/scilab/modules/overloading/macros/%spb_g_i.sci
new file mode 100644 (file)
index 0000000..41a589f
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%spb_g_i(spb1, i2)
+    res = spb1  |  (i2 <> 0);
+endfunction
diff --git a/scilab/modules/overloading/macros/%spb_g_s.sci b/scilab/modules/overloading/macros/%spb_g_s.sci
new file mode 100644 (file)
index 0000000..339e50f
--- /dev/null
@@ -0,0 +1,17 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%spb_g_s(spb1, s2)
+    res = spb1 | (s2 <> 0);
+endfunction
+
diff --git a/scilab/modules/overloading/macros/%spb_g_sp.sci b/scilab/modules/overloading/macros/%spb_g_sp.sci
new file mode 100644 (file)
index 0000000..48f969b
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%spb_g_sp(spb1,sp2)
+    res = (sp2<>0)  |  spb1;
+endfunction
diff --git a/scilab/modules/overloading/macros/%spb_g_spb.sci b/scilab/modules/overloading/macros/%spb_g_spb.sci
deleted file mode 100644 (file)
index a582c1f..0000000
+++ /dev/null
@@ -1,34 +0,0 @@
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) INRIA
-//
-// Copyright (C) 2012 - 2016 - Scilab Enterprises
-//
-// This file is hereby licensed under the terms of the GNU GPL v2.0,
-// pursuant to article 5.3.4 of the CeCILL v.2.1.
-// This file was originally licensed under the terms of the CeCILL v2.1,
-// and continues to be available under such terms.
-// For more information, see the COPYING file which you should have received
-// along with this program.
-
-function r=%spb_g_spb(a,b)
-    //  perform logical elementwise or a|b where a and b are boolean sparse
-    //  matrices
-
-    if prod(size(a))==1 then
-        if full(a) then
-            [mb,nb]==size(b)
-            r=(ones(mb,nb)==1)
-        else
-            r=b
-        end
-    elseif prod(size(b))==1  then
-        if full(b) then
-            [ma,na]==size(a)
-            r=(ones(ma,na)==1)
-        else
-            r=a
-        end
-    else
-        r=a|b
-    end
-endfunction
diff --git a/scilab/modules/overloading/macros/%spb_h_i.sci b/scilab/modules/overloading/macros/%spb_h_i.sci
new file mode 100644 (file)
index 0000000..1ec0343
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%spb_h_i(spb1, i2)
+    res = spb1  &  (i2 <> 0);
+endfunction
diff --git a/scilab/modules/overloading/macros/%spb_h_s.sci b/scilab/modules/overloading/macros/%spb_h_s.sci
new file mode 100644 (file)
index 0000000..644792d
--- /dev/null
@@ -0,0 +1,17 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%spb_h_s(spb1, s2)
+    res = spb1 & (s2 <> 0);
+endfunction
+
diff --git a/scilab/modules/overloading/macros/%spb_h_sp.sci b/scilab/modules/overloading/macros/%spb_h_sp.sci
new file mode 100644 (file)
index 0000000..cd2ce3a
--- /dev/null
@@ -0,0 +1,16 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) INRIA
+//
+// Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+//
+// This file is hereby licensed under the terms of the GNU GPL v2.0,
+// pursuant to article 5.3.4 of the CeCILL v.2.1.
+// This file was originally licensed under the terms of the CeCILL v2.1,
+// and continues to be available under such terms.
+// For more information, see the COPYING file which you should have received
+// along with this program.
+
+function res=%spb_h_sp(spb1,sp2)
+    res = (sp2<>0)  &  spb1;
+endfunction
@@ -2,6 +2,7 @@
 // Copyright (C) INRIA
 //
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Pierre-Aimé AGNEL
 //
 // This file is hereby licensed under the terms of the GNU GPL v2.0,
 // pursuant to article 5.3.4 of the CeCILL v.2.1.
@@ -9,8 +10,7 @@
 // and continues to be available under such terms.
 // For more information, see the COPYING file which you should have received
 // along with this program.
-function r=%b_g_s(a,b)
-    // r=a|b
 
-    r=a|(b<>0)
+function res = generic_s_g_s(s1, s2)
+    res = (s1 <> 0) | (s2 <> 0)
 endfunction
@@ -2,6 +2,7 @@
 // Copyright (C) INRIA
 //
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2016 - Pierre-Aimé AGNEL
 //
 // This file is hereby licensed under the terms of the GNU GPL v2.0,
 // pursuant to article 5.3.4 of the CeCILL v.2.1.
@@ -9,8 +10,7 @@
 // and continues to be available under such terms.
 // For more information, see the COPYING file which you should have received
 // along with this program.
-function r=%b_h_s(a,b)
-    // r=a&b
 
-    r=a&(b<>0)
+function res = generic_s_h_s(s1, s2)
+    res = (s1 <> 0) & (s2 <> 0)
 endfunction