move logicalOpExp algo to operations module and reforge it 86/11386/2
Antoine ELIAS [Wed, 24 Apr 2013 13:33:36 +0000 (15:33 +0200)]
Change-Id: I0b41ac5fe43318b2b8612afd198445a6fc5317b5

19 files changed:
scilab/modules/ast/includes/run_OpExp.hxx
scilab/modules/ast/includes/runvisitor.hxx
scilab/modules/ast/src/cpp/visitor_common.cpp
scilab/modules/operations/Makefile.am
scilab/modules/operations/Makefile.in
scilab/modules/operations/includes/generic_operations.hxx
scilab/modules/operations/includes/types_bitwiseOp.hxx [deleted file]
scilab/modules/operations/includes/types_comparison_eq.hxx
scilab/modules/operations/includes/types_comparison_lt_le_gt_ge.hxx
scilab/modules/operations/includes/types_or_and.hxx [new file with mode: 0644]
scilab/modules/operations/operations.vcxproj
scilab/modules/operations/operations.vcxproj.filters
scilab/modules/operations/src/cpp/types_bitwiseOp.cpp [deleted file]
scilab/modules/operations/src/cpp/types_comparison_eq.cpp
scilab/modules/operations/src/cpp/types_comparison_lt_le_gt_ge.cpp
scilab/modules/operations/src/cpp/types_or_and.cpp [new file with mode: 0644]
scilab/modules/operations/tests/unit_tests/or_and.dia.ref [new file with mode: 0644]
scilab/modules/operations/tests/unit_tests/or_and.tst [new file with mode: 0644]
scilab/modules/types/types.vcxproj

index 2b3907e..792b723 100644 (file)
@@ -200,242 +200,130 @@ void visitprivate(const OpExp &e)
 
 void visitprivate(const LogicalOpExp &e)
 {
-    e.left_get().accept(*this);
-    InternalType *pITL = result_get();
-    InternalType *pITR = NULL;
+    try
+    {
+        InternalType *pITR = NULL; //assign only in non shortcut operations.
 
-    GenericType::RealType TypeL = pITL->getType();
+        /*getting what to assign*/
+        e.left_get().accept(*this);
+        InternalType *pITL = result_get();
+        if (is_single_result() == false)
+        {
+            std::wostringstream os;
+            os << _W("Incompatible output argument.\n");
+            //os << ((Location)e.right_get().location_get()).location_getString() << std::endl;
+            throw ScilabError(os.str(), 999, e.right_get().location_get());
+        }
 
-    InternalType *pResult = NULL;
+        if (pITL->getType() == GenericType::RealImplicitList)
+        {
+            ImplicitList* pIL = pITL->getAs<ImplicitList>();
+            if (pIL->isComputable())
+            {
+                pITL = pIL->extractFullMatrix();
+            }
+        }
+
+        InternalType *pResult   = NULL;
 
-    if (TypeL == GenericType::RealBool)
-    {
-        Bool *pL = pITL->getAs<types::Bool>();
         switch (e.oper_get())
         {
-            case LogicalOpExp::logicalShortCutOr :
+            case LogicalOpExp::logicalShortCutAnd :
             {
-                int *piL       = pL->get();
-                bool iL     = true;
-                // Check if all values are true
-                // true || <something is always true>
-                for (int i = 0 ; i < pL->getSize() ; i++)
+                pResult = GenericShortcutAnd(pITL);
+                if (pResult)
                 {
-                    if (piL[i] == false)
-                    {
-                        iL = false;
-                        break;
-                    }
+                    break;
                 }
 
-                if (iL)
-                {
-                    //we don't need to look at ohers exp
-                    result_set(new Bool(true));
-                    return;
-                }
-                // DO NOT break here, falling into normal Or if this can not be shotcutted.
+                //Continue to logicalAnd
             }
-            case LogicalOpExp::logicalOr :
+            case LogicalOpExp::logicalAnd :
             {
+                /*getting what to assign*/
                 e.right_get().accept(*this);
                 pITR = result_get();
-                GenericType::RealType TypeR = pITR->getType();
-
-                if (TypeR == GenericType::RealBool)
+                if (is_single_result() == false)
                 {
-                    Bool *pR = pITR->getAs<types::Bool>();
-                    int* piR = pR->get();
-                    int* piL = pL->get();
-                    int* piB = NULL;
+                    std::wostringstream os;
+                    os << _W("Incompatible output argument.\n");
+                    //os << ((Location)e.right_get().location_get()).location_getString() << std::endl;
+                    throw ScilabError(os.str(), 999, e.right_get().location_get());
+                }
 
-                    // M | scalar
-                    if (pR->getSize() == 1)
-                    {
-                        pResult = new Bool(pL->getRows(), pL->getCols(), &piB);
-                        for (int i = 0 ; i < pL->getSize(); i++)
-                        {
-                            piB[i] = (piR[0] == 1) || (piL[i] == 1);
-                        }
-                    }
-                    else if (pL->getSize() == 1)
-                    {
-                        // scalar | M
-                        pResult = new Bool(pR->getRows(), pR->getCols(), &piB);
-                        for (int i = 0 ; i < pR->getSize(); i++)
-                        {
-                            piB[i] = (piR[i] == 1) || (piL[0] == 1);
-                        }
-                    }
-                    else if (pR->getRows() == pL->getRows() && pR->getCols() == pL->getCols())
-                    {
-                        // M | N (generic case)
-                        pResult = new Bool(pR->getRows(), pR->getCols(), &piB);
-                        for (int i = 0 ; i < pL->getSize(); i++)
-                        {
-                            piB[i] = (piR[i] == 1) || (piL[i] == 1);
-                        }
-                    }
-                    else
+                if (pITR->getType() == GenericType::RealImplicitList)
+                {
+                    ImplicitList* pIR = pITR->getAs<ImplicitList>();
+                    if (pIR->isComputable())
                     {
-                        std::wostringstream os;
-                        os << _W("Inconsistent row/column dimensions.\n");
-                        //os << ((Location)e.right_get().location_get()).location_getString() << std::endl;
-                        throw ScilabError(os.str(), 999, e.right_get().location_get());
+                        pITR = pIR->extractFullMatrix();
                     }
                 }
-                else
-                {
-                    pResult = callOverload(e.oper_get(), pITL, pITR);
-                }
+                pResult = GenericLogicalAnd(pITL, pITR);
                 break;
             }
-            case LogicalOpExp::logicalShortCutAnd :
+            case LogicalOpExp::logicalShortCutOr :
             {
-                int *piL       = pL->get();
-                // Check if one value is false
-                // false && <something> is always false
-                for (int i = 0 ; i < pL->getSize() ; i++)
+                pResult = GenericShortcutOr(pITL);
+                if (pResult)
                 {
-                    if (piL[i] == false)
-                    {
-                        result_set(new Bool(false));
-                        return;
-                    }
+                    break;
                 }
-                // DO NOT break here, falling into normal And if this can not be shotcutted.
+
+                //Continue to logicalAnd
             }
-            case LogicalOpExp::logicalAnd :
+            case LogicalOpExp::logicalOr :
             {
+                /*getting what to assign*/
                 e.right_get().accept(*this);
                 pITR = result_get();
-                GenericType::RealType TypeR = pITR->getType();
-
-                if (TypeR == GenericType::RealBool)
+                if (is_single_result() == false)
                 {
-                    Bool *pR = pITR->getAs<types::Bool>();
-                    int* piR = pR->get();
-                    int* piL = pL->get();
-                    int* piB = NULL;
+                    std::wostringstream os;
+                    os << _W("Incompatible output argument.\n");
+                    //os << ((Location)e.right_get().location_get()).location_getString() << std::endl;
+                    throw ScilabError(os.str(), 999, e.right_get().location_get());
+                }
 
-                    // M & scalar
-                    if (pR->getSize() == 1)
-                    {
-                        pResult = new Bool(pL->getRows(), pL->getCols(), &piB);
-                        for (int i = 0 ; i < pL->getSize(); i++)
-                        {
-                            piB[i] = (piR[0] == 1) && (piL[i] == 1);
-                        }
-                    }
-                    else if (pL->getSize() == 1)
-                    {
-                        // scalar & M
-                        pResult = new Bool(pR->getRows(), pR->getCols(), &piB);
-                        for (int i = 0 ; i < pR->getSize(); i++)
-                        {
-                            piB[i] = (piR[i] == 1) && (piL[0] == 1);
-                        }
-                    }
-                    else if (pR->getRows() == pL->getRows() && pR->getCols() == pL->getCols())
-                    {
-                        // M & N (generic case)
-                        pResult = new Bool(pR->getRows(), pR->getCols(), &piB);
-                        for (int i = 0 ; i < pL->getSize(); i++)
-                        {
-                            piB[i] = (piR[i] == 1) && (piL[i] == 1);
-                        }
-                    }
-                    else
+                if (pITR->getType() == GenericType::RealImplicitList)
+                {
+                    ImplicitList* pIR = pITR->getAs<ImplicitList>();
+                    if (pIR->isComputable())
                     {
-                        std::wostringstream os;
-                        os << _W("Inconsistent row/column dimensions.\n");
-                        //os << ((Location)e.right_get().location_get()).location_getString() << std::endl;
-                        throw ScilabError(os.str(), 999, e.right_get().location_get());
+                        pITR = pIR->extractFullMatrix();
                     }
                 }
-                else
-                {
-                    pResult = callOverload(e.oper_get(), pITL, pITR);
-                }
-                break;
-            }
-
-            default :
-            {
-                pResult = callOverload(e.oper_get(), pITL, pITR);
+                pResult = GenericLogicalOr(pITL, pITR);
                 break;
             }
         }
-    }
-    else if (pITL->isInt())
-    {
-        int iErr = 2;
-        e.right_get().accept(*this);
-        pITR = result_get();
-        GenericType::RealType TypeR = pITR->getType();
-
-        if (TypeL != TypeR)
+        //overloading
+        if (pResult == NULL)
         {
+            // We did not have any algorithm matching, so we try to call OverLoad
             pResult = callOverload(e.oper_get(), pITL, pITR);
         }
-        else
-        {
-            if (e.oper_get() == LogicalOpExp::logicalOr)
-            {
-                iErr = bitwiseOrToIntAndInt(pITL, pITR, &pResult);
-            }
-            else if (e.oper_get() == LogicalOpExp::logicalAnd)
-            {
-                iErr = bitwiseAndToIntAndInt(pITL, pITR, &pResult);
-            }
 
-            if (iErr)
-            {
-                std::wostringstream os;
-                switch (iErr)
-                {
-                    case 1:
-                        os << _W("Inconsistent row/column dimensions.\n");
-                        break;
-                    case 2:
-                        os << _W("Bad operator.\n");
-                        break; // if the operator is not logicalOr or logicalAnd
-                    case 3:
-                        os << _W("Bad type.\n");
-                        break;// should never be occured.
-                }
-                throw ScilabError(os.str(), 999, e.right_get().location_get());
-            }
-        }
-    }
-    else
-    {
-        e.right_get().accept(*this);
-        pITR = result_get();
-        switch (e.oper_get())
+        result_set(pResult);
+
+        //clear left and/or right operands
+        if (pITL->isDeletable())
         {
-            case LogicalOpExp::logicalShortCutOr :
-            case LogicalOpExp::logicalOr :
-            case LogicalOpExp::logicalShortCutAnd :
-            case LogicalOpExp::logicalAnd :
-                pResult = callOverload(e.oper_get(), pITL, pITR);
-                break;
-            default :
-                break;
+            delete pITL;
         }
-    }
 
-    if (pITL && pITL->isDeletable())
-    {
-        delete pITL;
+        if (pITR && pITR->isDeletable())
+        {
+            delete pITR;
+        }
     }
-
-    if (pITR && pITR->isDeletable())
+    catch (ScilabError error)
     {
-        delete pITR;
+        result_clear();
+        error.SetErrorLocation(e.location_get());
+        throw error;
     }
 
-    result_set(pResult);
 }
 
 types::InternalType* callOverload(OpExp::Oper _oper, types::InternalType* _paramL, types::InternalType* _paramR)
index f12a7ad..e14211c 100644 (file)
@@ -31,7 +31,7 @@
 // Needed by visitprivate(const OpExp &)
 // Needed by visitprivate(const LogicalOpExp &)
 #include "generic_operations.hxx"
-#include "types_bitwiseOp.hxx"
+#include "types_or_and.hxx"
 #include "configvariable.hxx"
 #include "overload.hxx"
 #include "scilabexception.hxx"
index f14734c..0d5c821 100644 (file)
@@ -25,6 +25,8 @@
 
 using namespace types;
 
+static bool isIntTrue(InternalType* _pIT);
+
 bool bConditionState(types::InternalType *_pITResult)
 {
     if (_pITResult->isDouble() &&
@@ -62,6 +64,7 @@ bool bConditionState(types::InternalType *_pITResult)
     }
     else if (_pITResult->isInt())
     {
+        return isIntTrue(_pITResult);
     }
     else
     {
@@ -70,6 +73,61 @@ bool bConditionState(types::InternalType *_pITResult)
     return true;
 }
 
+template <class K>
+static bool isIntTrue(K* _pI)
+{
+    for (int i = 0 ; i < _pI->getSize() ; i++)
+    {
+        if (_pI->get(i) == 0)
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool isIntTrue(InternalType* _pIT)
+{
+    switch (_pIT->getType())
+    {
+        case InternalType::RealInt8 :
+        {
+            return isIntTrue(_pIT->getAs<Int8>());
+        }
+        case InternalType::RealUInt8 :
+        {
+            return isIntTrue(_pIT->getAs<UInt8>());
+        }
+        case InternalType::RealInt16 :
+        {
+            return isIntTrue(_pIT->getAs<Int16>());
+        }
+        case InternalType::RealUInt16 :
+        {
+            return isIntTrue(_pIT->getAs<UInt16>());
+        }
+        case InternalType::RealInt32 :
+        {
+            return isIntTrue(_pIT->getAs<Int32>());
+        }
+        case InternalType::RealUInt32 :
+        {
+            return isIntTrue(_pIT->getAs<UInt32>());
+        }
+        case InternalType::RealInt64 :
+        {
+            return isIntTrue(_pIT->getAs<Int64>());
+        }
+        case InternalType::RealUInt64 :
+        {
+            return isIntTrue(_pIT->getAs<UInt64>());
+        }
+    }
+
+    return false;
+}
+
 /*
  * Generate destination variable from _poSource type and size parameters
  */
index d19aec7..5481b69 100644 (file)
@@ -26,7 +26,7 @@ OPERATIONS_CPP_SOURCES =  src/cpp/operations.cpp \
                        src/cpp/types_comparison_lt_le_gt_ge.cpp \
                        src/cpp/types_kronecker.cpp \
                        src/cpp/types_comparison_ne.cpp \
-                       src/cpp/types_bitwiseOp.cpp
+                       src/cpp/types_or_and.cpp
 
 pkglib_LTLIBRARIES = libscioperations.la
 
index ac0e3b2..370487c 100644 (file)
@@ -154,7 +154,7 @@ am__objects_2 = libscioperations_la-operations.lo \
        libscioperations_la-types_comparison_lt_le_gt_ge.lo \
        libscioperations_la-types_kronecker.lo \
        libscioperations_la-types_comparison_ne.lo \
-       libscioperations_la-types_bitwiseOp.lo
+       libscioperations_la-types_or_and.lo
 am_libscioperations_la_OBJECTS = $(am__objects_1) $(am__objects_2)
 libscioperations_la_OBJECTS = $(am_libscioperations_la_OBJECTS)
 libscioperations_la_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \
@@ -481,7 +481,7 @@ OPERATIONS_CPP_SOURCES = src/cpp/operations.cpp \
                        src/cpp/types_comparison_lt_le_gt_ge.cpp \
                        src/cpp/types_kronecker.cpp \
                        src/cpp/types_comparison_ne.cpp \
-                       src/cpp/types_bitwiseOp.cpp
+                       src/cpp/types_or_and.cpp
 
 pkglib_LTLIBRARIES = libscioperations.la
 libscioperations_la_LDFLAGS = -version-info $(SCILAB_LIBRARY_VERSION)
@@ -673,7 +673,6 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-operations.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-operations_tools.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_addition.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_bitwiseOp.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_comparison_eq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_comparison_lt_le_gt_ge.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_comparison_ne.Plo@am__quote@
@@ -682,6 +681,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_kronecker.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_ldivide.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_multiplication.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_or_and.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_power.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioperations_la-types_substraction.Plo@am__quote@
 
@@ -881,12 +881,12 @@ libscioperations_la-types_comparison_ne.lo: src/cpp/types_comparison_ne.cpp
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@     DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@ $(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioperations_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libscioperations_la-types_comparison_ne.lo `test -f 'src/cpp/types_comparison_ne.cpp' || echo '$(srcdir)/'`src/cpp/types_comparison_ne.cpp
 
-libscioperations_la-types_bitwiseOp.lo: src/cpp/types_bitwiseOp.cpp
-@am__fastdepCXX_TRUE@  $(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioperations_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libscioperations_la-types_bitwiseOp.lo -MD -MP -MF $(DEPDIR)/libscioperations_la-types_bitwiseOp.Tpo -c -o libscioperations_la-types_bitwiseOp.lo `test -f 'src/cpp/types_bitwiseOp.cpp' || echo '$(srcdir)/'`src/cpp/types_bitwiseOp.cpp
-@am__fastdepCXX_TRUE@  $(am__mv) $(DEPDIR)/libscioperations_la-types_bitwiseOp.Tpo $(DEPDIR)/libscioperations_la-types_bitwiseOp.Plo
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@     source='src/cpp/types_bitwiseOp.cpp' object='libscioperations_la-types_bitwiseOp.lo' libtool=yes @AMDEPBACKSLASH@
+libscioperations_la-types_or_and.lo: src/cpp/types_or_and.cpp
+@am__fastdepCXX_TRUE@  $(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioperations_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libscioperations_la-types_or_and.lo -MD -MP -MF $(DEPDIR)/libscioperations_la-types_or_and.Tpo -c -o libscioperations_la-types_or_and.lo `test -f 'src/cpp/types_or_and.cpp' || echo '$(srcdir)/'`src/cpp/types_or_and.cpp
+@am__fastdepCXX_TRUE@  $(am__mv) $(DEPDIR)/libscioperations_la-types_or_and.Tpo $(DEPDIR)/libscioperations_la-types_or_and.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@     source='src/cpp/types_or_and.cpp' object='libscioperations_la-types_or_and.lo' libtool=yes @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@     DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@ $(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioperations_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libscioperations_la-types_bitwiseOp.lo `test -f 'src/cpp/types_bitwiseOp.cpp' || echo '$(srcdir)/'`src/cpp/types_bitwiseOp.cpp
+@am__fastdepCXX_FALSE@ $(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioperations_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libscioperations_la-types_or_and.lo `test -f 'src/cpp/types_or_and.cpp' || echo '$(srcdir)/'`src/cpp/types_or_and.cpp
 
 mostlyclean-libtool:
        -rm -f *.lo
index f3f83d3..f0de94e 100644 (file)
@@ -85,4 +85,19 @@ EXTERN_OP types::InternalType* GenericKronrdivide(types::InternalType *_pLeftOpe
 
 // .\.
 EXTERN_OP types::InternalType* GenericKronldivide(types::InternalType *_pLeftOperand, types::InternalType *_pRightOperand);
+
+// &&
+EXTERN_OP types::InternalType* GenericShortcutAnd(types::InternalType *_pLeftOperand);
+
+// &
+EXTERN_OP types::InternalType* GenericLogicalAnd(types::InternalType *_pLeftOperand, types::InternalType *_pRightOperand);
+
+// ||
+EXTERN_OP types::InternalType* GenericShortcutOr(types::InternalType *_pLeftOperand);
+
+// |
+EXTERN_OP types::InternalType* GenericLogicalOr(types::InternalType *_pLeftOperand, types::InternalType *_pRightOperand);
+
 #endif /* !__GENERIC_OPERATIONS_HXX__ */
+
+
diff --git a/scilab/modules/operations/includes/types_bitwiseOp.hxx b/scilab/modules/operations/includes/types_bitwiseOp.hxx
deleted file mode 100644 (file)
index 8457c05..0000000
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- *  Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
- *
- *  This file must be used under the terms of the CeCILL.
- *  This source file is licensed as described in the file COPYING, which
- *  you should have received as part of this distribution.  The terms
- *  are also available at
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
-
-#ifndef __TYPES_BITWISEOP_H__
-#define __TYPES_BITWISEOP_H__
-
-#include "dynlib_operations.hxx"
-#include "types.hxx"
-
-EXTERN_OP int bitwiseAndToIntAndInt(types::InternalType* _pI1, types::InternalType*  _pI2, types::InternalType** _pOut);
-template <class K>
-int bitwiseAndToIntAndInt(K* _pI1, K* _pI2, types::InternalType** _pOut);
-
-EXTERN_OP int bitwiseOrToIntAndInt(types::InternalType* _pI1, types::InternalType*  _pI2, types::InternalType** _pOut);
-template <class K>
-int bitwiseOrToIntAndInt(K* _pI1, K* _pI2, types::InternalType** _pOut);
-
-#endif /* __TYPES_BITWISEOP_H__ */
\ No newline at end of file
index dd8b16c..121034e 100644 (file)
@@ -28,7 +28,5 @@ int EqualToSparseBoolAndBool(types::SparseBool* _pSB1, types::Bool* _pB2, types:
 int EqualToBoolAndSparseBool(types::Bool* _pB1, types::SparseBool* _pSB2, types::GenericType** _pOut);
 
 int EqualToIntAndInt(types::InternalType* _pI1, types::InternalType*  _pI2, types::GenericType** _pOut);
-template <class T>
-int EqualToIntAndInt(T* _pI1, T* _pI2, types::GenericType** _pOut);
 
 #endif /* !__TYPES_COMPARISON_EQUAL_HXX__ */
index adacc2a..0ada713 100644 (file)
@@ -30,12 +30,7 @@ int SparseLessSparse(types::Sparse* _pSparse1, types::Sparse* _pSparse2, types::
 int SparseLessEqualSparse(types::Sparse* _pSparse1, types::Sparse* _pSparse2, types::SparseBool** _pOut);
 
 int IntLessInt(types::InternalType* _pI1, types::InternalType*  _pI2, types::GenericType** _pOut);
-template <class T>
-int IntLessInt(T* _pI1, T* _pI2, types::GenericType** _pOut);
-
 int IntLessEqualInt(types::InternalType* _pI1, types::InternalType*  _pI2, types::GenericType** _pOut);
-template <class T>
-int IntLessEqualInt(T* _pI1, T* _pI2, types::GenericType** _pOut);
 
 
 #endif /* !__TYPES_COMPARAISON_LT_LE_HXX__ */
diff --git a/scilab/modules/operations/includes/types_or_and.hxx b/scilab/modules/operations/includes/types_or_and.hxx
new file mode 100644 (file)
index 0000000..25f4904
--- /dev/null
@@ -0,0 +1,37 @@
+/*
+ *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ *  Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
+ *
+ *  This file must be used under the terms of the CeCILL.
+ *  This source file is licensed as described in the file COPYING, which
+ *  you should have received as part of this distribution.  The terms
+ *  are also available at
+ *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
+
+#ifndef __TYPES_BITWISEOP_H__
+#define __TYPES_BITWISEOP_H__
+
+#include "dynlib_operations.hxx"
+#include "generic_operations.hxx"
+#include "types.hxx"
+#include "bool.hxx"
+
+// &&
+EXTERN_OP int IntAndInt(types::InternalType* _pL, types::Bool** _pOut);
+EXTERN_OP int BoolAndBool(types::Bool* _pL, types::Bool** _pOut);
+
+// &
+EXTERN_OP int IntLogicalAndInt(types::InternalType* _pL, types::InternalType*  _pR, types::InternalType** _pOut);
+EXTERN_OP int BoolLogicalAndBool(types::Bool* _pL, types::Bool*  _pR, types::Bool** _pOut);
+
+// ||
+EXTERN_OP int IntOrInt(types::InternalType* _pL, types::Bool** _pOut);
+EXTERN_OP int BoolOrBool(types::Bool* _pI1, types::Bool** _pOut);
+
+// |
+EXTERN_OP int IntLogicalOrInt(types::InternalType* _pL, types::InternalType*  _pR, types::InternalType** _pOut);
+EXTERN_OP int BoolLogicalOrBool(types::Bool* _pL, types::Bool*  _pR, types::Bool** _pOut);
+
+#endif /* __TYPES_BITWISEOP_H__ */
\ No newline at end of file
index 1074725..1ae0a5c 100644 (file)
@@ -218,7 +218,7 @@ lib /DEF:"$(ProjectDir)system_env_Import.def" /SUBSYSTEM:WINDOWS /MACHINE:$(Plat
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="src\cpp\types_bitwiseOp.cpp" />
+    <ClCompile Include="src\cpp\types_or_and.cpp" />
     <ClCompile Include="src\cpp\types_comparison_eq.cpp" />
     <ClCompile Include="src\cpp\types_comparison_lt_le_gt_ge.cpp" />
     <ClCompile Include="src\cpp\types_comparison_ne.cpp" />
@@ -259,7 +259,7 @@ lib /DEF:"$(ProjectDir)system_env_Import.def" /SUBSYSTEM:WINDOWS /MACHINE:$(Plat
     <ClInclude Include="includes\matrix_transpose_int.hxx" />
     <ClInclude Include="includes\operations_tools.h" />
     <ClInclude Include="includes\types_addition.hxx" />
-    <ClInclude Include="includes\types_bitwiseOp.hxx" />
+    <ClInclude Include="includes\types_or_and.hxx" />
     <ClInclude Include="includes\types_comparison_eq.hxx" />
     <ClInclude Include="includes\types_comparison_lt_le_gt_ge.hxx" />
     <ClInclude Include="includes\types_comparison_ne.hxx" />
index d24de24..d3c71e8 100644 (file)
     <ClCompile Include="src\c\matrix_transpose.c">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\cpp\types_bitwiseOp.cpp">
+    <ClCompile Include="src\cpp\types_ldivide.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\cpp\types_ldivide.cpp">
+    <ClCompile Include="src\cpp\types_or_and.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
     <ClInclude Include="includes\matrix_transpose_int.hxx">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="includes\types_bitwiseOp.hxx">
+    <ClInclude Include="includes\types_ldivide.hxx">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="includes\types_ldivide.hxx">
+    <ClInclude Include="includes\types_or_and.hxx">
       <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
diff --git a/scilab/modules/operations/src/cpp/types_bitwiseOp.cpp b/scilab/modules/operations/src/cpp/types_bitwiseOp.cpp
deleted file mode 100644 (file)
index 2f491f9..0000000
+++ /dev/null
@@ -1,244 +0,0 @@
-/*
- *  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
- *
- *  This file must be used under the terms of the CeCILL.
- *  This source file is licensed as described in the file COPYING, which
- *  you should have received as part of this distribution.  The terms
- *  are also available at
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
-
-#include "types_bitwiseOp.hxx"
-#include "int.hxx"
-
-int bitwiseAndToIntAndInt(types::InternalType* _pL, types::InternalType*  _pR, types::InternalType** _pOut)
-{
-    switch (_pL->getType())
-    {
-        case types::InternalType::RealInt8 :
-        {
-            types::Int8* pI1 = _pL->getAs<types::Int8>();
-            types::Int8* pI2 = _pR->getAs<types::Int8>();
-            return bitwiseAndToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealUInt8 :
-        {
-            types::UInt8* pI1 = _pL->getAs<types::UInt8>();
-            types::UInt8* pI2 = _pR->getAs<types::UInt8>();
-            return bitwiseAndToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealInt16 :
-        {
-            types::Int16* pI1 = _pL->getAs<types::Int16>();
-            types::Int16* pI2 = _pR->getAs<types::Int16>();
-            return bitwiseAndToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealUInt16 :
-        {
-            types::UInt16* pI1 = _pL->getAs<types::UInt16>();
-            types::UInt16* pI2 = _pR->getAs<types::UInt16>();
-            return bitwiseAndToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealInt32 :
-        {
-            types::Int32* pI1 = _pL->getAs<types::Int32>();
-            types::Int32* pI2 = _pR->getAs<types::Int32>();
-            return bitwiseAndToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealUInt32 :
-        {
-            types::UInt32* pI1 = _pL->getAs<types::UInt32>();
-            types::UInt32* pI2 = _pR->getAs<types::UInt32>();
-            return bitwiseAndToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealInt64 :
-        {
-            types::Int64* pI1 = _pL->getAs<types::Int64>();
-            types::Int64* pI2 = _pR->getAs<types::Int64>();
-            return bitwiseAndToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealUInt64 :
-        {
-            types::UInt64* pI1 = _pL->getAs<types::UInt64>();
-            types::UInt64* pI2 = _pR->getAs<types::UInt64>();
-            return bitwiseAndToIntAndInt(pI1, pI2, _pOut);
-        }
-    }
-
-    return 3;
-}
-
-template <class K>
-int bitwiseAndToIntAndInt(K* _pL, K* _pR, types::InternalType** _pOut)
-{
-    // left scalar bitwise and right matrix
-    if (_pL->isScalar())
-    {
-        K *pI = new K(_pR->getDims(), _pR->getDimsArray());
-        for (int i = 0 ; i < pI->getSize() ; i++)
-        {
-            pI->set(i, _pL->get(0) & _pR->get(i));
-        }
-
-        *_pOut = pI;
-        return 0;
-    }
-
-    // right scalar bitwise and left matrix
-    if (_pR->isScalar())
-    {
-        K *pI = new K(_pL->getDims(), _pL->getDimsArray());
-        for (int i = 0 ; i < pI->getSize() ; i++)
-        {
-            pI->set(i, _pR->get(0) & _pL->get(i));
-        }
-
-        *_pOut = pI;
-        return 0;
-    }
-
-    // check dims
-    if (_pL->getDims() != _pR->getDims())
-    {
-        return 1;
-    }
-
-    int* piDimsL = _pL->getDimsArray();
-    int* piDimsR = _pR->getDimsArray();
-
-    for (int i = 0 ; i < _pL->getDims() ; i++)
-    {
-        if (piDimsL[i] != piDimsR[i])
-        {
-            return 1;
-        }
-    }
-
-    // left matrix bitwise and right matrix
-    K* pI = new K(_pR->getDims(), _pR->getDimsArray());
-    for (int i = 0 ; i < _pL->getSize() ; i++)
-    {
-        pI->set(i, _pL->get(i) & _pR->get(i));
-    }
-
-    *_pOut = pI;
-    return 0;
-}
-
-
-int bitwiseOrToIntAndInt(types::InternalType* _pL, types::InternalType*  _pR, types::InternalType** _pOut)
-{
-    switch (_pL->getType())
-    {
-        case types::InternalType::RealInt8 :
-        {
-            types::Int8* pI1 = _pL->getAs<types::Int8>();
-            types::Int8* pI2 = _pR->getAs<types::Int8>();
-            return bitwiseOrToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealUInt8 :
-        {
-            types::UInt8* pI1 = _pL->getAs<types::UInt8>();
-            types::UInt8* pI2 = _pR->getAs<types::UInt8>();
-            return bitwiseOrToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealInt16 :
-        {
-            types::Int16* pI1 = _pL->getAs<types::Int16>();
-            types::Int16* pI2 = _pR->getAs<types::Int16>();
-            return bitwiseOrToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealUInt16 :
-        {
-            types::UInt16* pI1 = _pL->getAs<types::UInt16>();
-            types::UInt16* pI2 = _pR->getAs<types::UInt16>();
-            return bitwiseOrToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealInt32 :
-        {
-            types::Int32* pI1 = _pL->getAs<types::Int32>();
-            types::Int32* pI2 = _pR->getAs<types::Int32>();
-            return bitwiseOrToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealUInt32 :
-        {
-            types::UInt32* pI1 = _pL->getAs<types::UInt32>();
-            types::UInt32* pI2 = _pR->getAs<types::UInt32>();
-            return bitwiseOrToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealInt64 :
-        {
-            types::Int64* pI1 = _pL->getAs<types::Int64>();
-            types::Int64* pI2 = _pR->getAs<types::Int64>();
-            return bitwiseOrToIntAndInt(pI1, pI2, _pOut);
-        }
-        case types::InternalType::RealUInt64 :
-        {
-            types::UInt64* pI1 = _pL->getAs<types::UInt64>();
-            types::UInt64* pI2 = _pR->getAs<types::UInt64>();
-            return bitwiseOrToIntAndInt(pI1, pI2, _pOut);
-        }
-    }
-
-    return 3;
-}
-
-template <class K>
-int bitwiseOrToIntAndInt(K* _pL, K* _pR, types::InternalType** _pOut)
-{
-    // left scalar bitwise or right matrix
-    if (_pL->isScalar())
-    {
-        K *pI = new K(_pR->getDims(), _pR->getDimsArray());
-        for (int i = 0 ; i < pI->getSize() ; i++)
-        {
-            pI->set(i, _pL->get(0) | _pR->get(i));
-        }
-
-        *_pOut = pI;
-        return 0;
-    }
-
-    // right scalar bitwise or left matrix
-    if (_pR->isScalar())
-    {
-        K *pI = new K(_pL->getDims(), _pL->getDimsArray());
-        for (int i = 0 ; i < pI->getSize() ; i++)
-        {
-            pI->set(i, _pR->get(0) | _pL->get(i));
-        }
-
-        *_pOut = pI;
-        return 0;
-    }
-
-    // check dims
-    if (_pL->getDims() != _pR->getDims())
-    {
-        return 1;
-    }
-
-    int* piDimsL = _pL->getDimsArray();
-    int* piDimsR = _pR->getDimsArray();
-
-    for (int i = 0 ; i < _pL->getDims() ; i++)
-    {
-        if (piDimsL[i] != piDimsR[i])
-        {
-            return 1;
-        }
-    }
-
-    // left matrix bitwise or right matrix
-    K* pI = new K(_pR->getDims(), _pR->getDimsArray());
-    for (int i = 0 ; i < _pL->getSize() ; i++)
-    {
-        pI->set(i, _pL->get(i) | _pR->get(i));
-    }
-
-    *_pOut = pI;
-    return 0;
-}
index 1658ad0..4c1633a 100644 (file)
@@ -813,65 +813,8 @@ int EqualToBoolAndSparseBool(Bool* _pB1, SparseBool* _pSB2, GenericType** _pOut)
     return iRet;
 }
 
-int EqualToIntAndInt(InternalType* _pL, InternalType*  _pR, GenericType** _pOut)
-{
-    switch (_pL->getType())
-    {
-        case InternalType::RealInt8 :
-        {
-            Int8* pI1 = _pL->getAs<Int8>();
-            Int8* pI2 = _pR->getAs<Int8>();
-            return EqualToIntAndInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealUInt8 :
-        {
-            UInt8* pI1 = _pL->getAs<UInt8>();
-            UInt8* pI2 = _pR->getAs<UInt8>();
-            return EqualToIntAndInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealInt16 :
-        {
-            Int16* pI1 = _pL->getAs<Int16>();
-            Int16* pI2 = _pR->getAs<Int16>();
-            return EqualToIntAndInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealUInt16 :
-        {
-            UInt16* pI1 = _pL->getAs<UInt16>();
-            UInt16* pI2 = _pR->getAs<UInt16>();
-            return EqualToIntAndInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealInt32 :
-        {
-            Int32* pI1 = _pL->getAs<Int32>();
-            Int32* pI2 = _pR->getAs<Int32>();
-            return EqualToIntAndInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealUInt32 :
-        {
-            UInt32* pI1 = _pL->getAs<UInt32>();
-            UInt32* pI2 = _pR->getAs<UInt32>();
-            return EqualToIntAndInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealInt64 :
-        {
-            Int64* pI1 = _pL->getAs<Int64>();
-            Int64* pI2 = _pR->getAs<Int64>();
-            return EqualToIntAndInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealUInt64 :
-        {
-            UInt64* pI1 = _pL->getAs<UInt64>();
-            UInt64* pI2 = _pR->getAs<UInt64>();
-            return EqualToIntAndInt(pI1, pI2, _pOut);
-        }
-    }
-
-    return 0;
-}
-
 template <class T>
-int EqualToIntAndInt(T* _pL, T* _pR, GenericType** _pOut)
+static int EqualToIntAndInt(T* _pL, T* _pR, GenericType** _pOut)
 {
     if (_pL->isScalar())
     {
@@ -931,6 +874,47 @@ int EqualToIntAndInt(T* _pL, T* _pR, GenericType** _pOut)
     return 0;
 }
 
+int EqualToIntAndInt(InternalType* _pL, InternalType*  _pR, GenericType** _pOut)
+{
+    switch (_pL->getType())
+    {
+        case InternalType::RealInt8 :
+        {
+            return EqualToIntAndInt(_pL->getAs<Int8>(), _pR->getAs<Int8>(), _pOut);
+        }
+        case InternalType::RealUInt8 :
+        {
+            return EqualToIntAndInt(_pL->getAs<UInt8>(), _pR->getAs<UInt8>(), _pOut);
+        }
+        case InternalType::RealInt16 :
+        {
+            return EqualToIntAndInt(_pL->getAs<Int16>(), _pR->getAs<Int16>(), _pOut);
+        }
+        case InternalType::RealUInt16 :
+        {
+            return EqualToIntAndInt(_pL->getAs<UInt16>(), _pR->getAs<UInt16>(), _pOut);
+        }
+        case InternalType::RealInt32 :
+        {
+            return EqualToIntAndInt(_pL->getAs<Int32>(), _pR->getAs<Int32>(), _pOut);
+        }
+        case InternalType::RealUInt32 :
+        {
+            return EqualToIntAndInt(_pL->getAs<UInt32>(), _pR->getAs<UInt32>(), _pOut);
+        }
+        case InternalType::RealInt64 :
+        {
+            return EqualToIntAndInt(_pL->getAs<Int64>(), _pR->getAs<Int64>(), _pOut);
+        }
+        case InternalType::RealUInt64 :
+        {
+            return EqualToIntAndInt(_pL->getAs<UInt64>(), _pR->getAs<UInt64>(), _pOut);
+        }
+    }
+
+    return 3;
+}
+
 static void clearAlloc(bool _bAllocL, InternalType* _pIL, bool _bAllocR, InternalType* _pIR)
 {
     if (_bAllocL)
index 559ad22..7a07e21 100644 (file)
@@ -460,65 +460,8 @@ InternalType *GenericGreaterEqual(InternalType *_pLeftOperand, InternalType *_pR
     return GenericLessEqual(_pRightOperand, _pLeftOperand);
 }
 
-int IntLessInt(types::InternalType* _pL, types::InternalType*  _pR, types::GenericType** _pOut)
-{
-    switch (_pL->getType())
-    {
-        case InternalType::RealInt8 :
-        {
-            Int8* pI1 = _pL->getAs<Int8>();
-            Int8* pI2 = _pR->getAs<Int8>();
-            return IntLessInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealUInt8 :
-        {
-            UInt8* pI1 = _pL->getAs<UInt8>();
-            UInt8* pI2 = _pR->getAs<UInt8>();
-            return IntLessInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealInt16 :
-        {
-            Int16* pI1 = _pL->getAs<Int16>();
-            Int16* pI2 = _pR->getAs<Int16>();
-            return IntLessInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealUInt16 :
-        {
-            UInt16* pI1 = _pL->getAs<UInt16>();
-            UInt16* pI2 = _pR->getAs<UInt16>();
-            return IntLessInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealInt32 :
-        {
-            Int32* pI1 = _pL->getAs<Int32>();
-            Int32* pI2 = _pR->getAs<Int32>();
-            return IntLessInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealUInt32 :
-        {
-            UInt32* pI1 = _pL->getAs<UInt32>();
-            UInt32* pI2 = _pR->getAs<UInt32>();
-            return IntLessInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealInt64 :
-        {
-            Int64* pI1 = _pL->getAs<Int64>();
-            Int64* pI2 = _pR->getAs<Int64>();
-            return IntLessInt(pI1, pI2, _pOut);
-        }
-        case InternalType::RealUInt64 :
-        {
-            UInt64* pI1 = _pL->getAs<UInt64>();
-            UInt64* pI2 = _pR->getAs<UInt64>();
-            return IntLessInt(pI1, pI2, _pOut);
-        }
-    }
-
-    return 0;
-}
-
 template <class T>
-int IntLessInt(T* _pL, T* _pR, types::GenericType** _pOut)
+static int IntLessInt(T* _pL, T* _pR, types::GenericType** _pOut)
 {
     if (_pL->isScalar())
     {
@@ -576,57 +519,41 @@ int IntLessInt(T* _pL, T* _pR, types::GenericType** _pOut)
     return 0;
 }
 
-int IntLessEqualInt(types::InternalType* _pL, types::InternalType* _pR, types::GenericType** _pOut)
+int IntLessInt(types::InternalType* _pL, types::InternalType*  _pR, types::GenericType** _pOut)
 {
     switch (_pL->getType())
     {
         case InternalType::RealInt8 :
         {
-            Int8* pI1 = _pL->getAs<Int8>();
-            Int8* pI2 = _pR->getAs<Int8>();
-            return IntLessEqualInt(pI1, pI2, _pOut);
+            return IntLessInt(_pL->getAs<Int8>(), _pR->getAs<Int8>(), _pOut);
         }
         case InternalType::RealUInt8 :
         {
-            UInt8* pI1 = _pL->getAs<UInt8>();
-            UInt8* pI2 = _pR->getAs<UInt8>();
-            return IntLessEqualInt(pI1, pI2, _pOut);
+            return IntLessInt(_pL->getAs<UInt8>(), _pR->getAs<UInt8>(), _pOut);
         }
         case InternalType::RealInt16 :
         {
-            Int16* pI1 = _pL->getAs<Int16>();
-            Int16* pI2 = _pR->getAs<Int16>();
-            return IntLessEqualInt(pI1, pI2, _pOut);
+            return IntLessInt(_pL->getAs<Int16>(), _pR->getAs<Int16>(), _pOut);
         }
         case InternalType::RealUInt16 :
         {
-            UInt16* pI1 = _pL->getAs<UInt16>();
-            UInt16* pI2 = _pR->getAs<UInt16>();
-            return IntLessEqualInt(pI1, pI2, _pOut);
+            return IntLessInt(_pL->getAs<UInt16>(), _pR->getAs<UInt16>(), _pOut);
         }
         case InternalType::RealInt32 :
         {
-            Int32* pI1 = _pL->getAs<Int32>();
-            Int32* pI2 = _pR->getAs<Int32>();
-            return IntLessEqualInt(pI1, pI2, _pOut);
+            return IntLessInt(_pL->getAs<Int32>(), _pR->getAs<Int32>(), _pOut);
         }
         case InternalType::RealUInt32 :
         {
-            UInt32* pI1 = _pL->getAs<UInt32>();
-            UInt32* pI2 = _pR->getAs<UInt32>();
-            return IntLessEqualInt(pI1, pI2, _pOut);
+            return IntLessInt(_pL->getAs<UInt32>(), _pR->getAs<UInt32>(), _pOut);
         }
         case InternalType::RealInt64 :
         {
-            Int64* pI1 = _pL->getAs<Int64>();
-            Int64* pI2 = _pR->getAs<Int64>();
-            return IntLessInt(pI1, pI2, _pOut);
+            return IntLessInt(_pL->getAs<Int64>(), _pR->getAs<Int64>(), _pOut);
         }
         case InternalType::RealUInt64 :
         {
-            UInt64* pI1 = _pL->getAs<UInt64>();
-            UInt64* pI2 = _pR->getAs<UInt64>();
-            return IntLessEqualInt(pI1, pI2, _pOut);
+            return IntLessInt(_pL->getAs<UInt64>(), _pR->getAs<UInt64>(), _pOut);
         }
     }
 
@@ -634,7 +561,7 @@ int IntLessEqualInt(types::InternalType* _pL, types::InternalType* _pR, types::G
 }
 
 template <class T>
-int IntLessEqualInt(T* _pL, T* _pR, types::GenericType** _pOut)
+static int IntLessEqualInt(T* _pL, T* _pR, types::GenericType** _pOut)
 {
     if (_pL->isScalar())
     {
@@ -691,3 +618,44 @@ int IntLessEqualInt(T* _pL, T* _pR, types::GenericType** _pOut)
     *_pOut = pB;
     return 0;
 }
+
+int IntLessEqualInt(types::InternalType* _pL, types::InternalType* _pR, types::GenericType** _pOut)
+{
+    switch (_pL->getType())
+    {
+        case InternalType::RealInt8 :
+        {
+            return IntLessEqualInt(_pL->getAs<Int8>(), _pR->getAs<Int8>(), _pOut);
+        }
+        case InternalType::RealUInt8 :
+        {
+            return IntLessEqualInt(_pL->getAs<UInt8>(), _pR->getAs<UInt8>(), _pOut);
+        }
+        case InternalType::RealInt16 :
+        {
+            return IntLessEqualInt(_pL->getAs<Int16>(), _pR->getAs<Int16>(), _pOut);
+        }
+        case InternalType::RealUInt16 :
+        {
+            return IntLessEqualInt(_pL->getAs<UInt16>(), _pR->getAs<UInt16>(), _pOut);
+        }
+        case InternalType::RealInt32 :
+        {
+            return IntLessEqualInt(_pL->getAs<Int32>(), _pR->getAs<Int32>(), _pOut);
+        }
+        case InternalType::RealUInt32 :
+        {
+            return IntLessEqualInt(_pL->getAs<UInt32>(), _pR->getAs<UInt32>(), _pOut);
+        }
+        case InternalType::RealInt64 :
+        {
+            return IntLessEqualInt(_pL->getAs<Int64>(), _pR->getAs<Int64>(), _pOut);
+        }
+        case InternalType::RealUInt64 :
+        {
+            return IntLessEqualInt(_pL->getAs<UInt64>(), _pR->getAs<UInt64>(), _pOut);
+        }
+    }
+
+    return 0;
+}
diff --git a/scilab/modules/operations/src/cpp/types_or_and.cpp b/scilab/modules/operations/src/cpp/types_or_and.cpp
new file mode 100644 (file)
index 0000000..408ba54
--- /dev/null
@@ -0,0 +1,581 @@
+/*
+ *  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
+ *
+ *  This file must be used under the terms of the CeCILL.
+ *  This source file is licensed as described in the file COPYING, which
+ *  you should have received as part of this distribution.  The terms
+ *  are also available at
+ *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
+
+#include "types_or_and.hxx"
+#include "int.hxx"
+#include "bool.hxx"
+
+extern "C"
+{
+#include "os_swprintf.h"
+}
+
+using namespace types;
+
+// &&
+InternalType* GenericShortcutAnd(InternalType* _pL)
+{
+    InternalType* pResult = NULL;
+    if (_pL->isBool())
+    {
+        BoolAndBool(_pL->getAs<Bool>(), (Bool**)&pResult);
+    }
+
+    if (_pL->isInt())
+    {
+        IntAndInt(_pL, (Bool**)&pResult);
+    }
+
+    return pResult;
+}
+
+// &
+InternalType* GenericLogicalAnd(InternalType* _pL, InternalType* _pR)
+{
+    InternalType* pResult = NULL;
+
+    if (_pL->isBool() && _pR->isBool())
+    {
+        Bool *pL = (Bool*)_pL;
+        Bool *pR = (Bool*)_pR;
+
+        int iResult = BoolLogicalAndBool(pL, pR, (Bool**)&pResult);
+        if (iResult != 0)
+        {
+            wchar_t pMsg[bsiz];
+            os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n"), L"&", pL->DimToString().c_str(), pR->DimToString().c_str());
+            throw ast::ScilabError(pMsg);
+        }
+        return pResult;
+    }
+
+    if (_pL->isInt() && _pR->isInt())
+    {
+        int iResult = IntLogicalAndInt(_pL, _pR, &pResult);
+        if (iResult != 0)
+        {
+            GenericType* pL = _pL->getAs<GenericType>();
+            GenericType* pR = _pR->getAs<GenericType>();
+            wchar_t pMsg[bsiz];
+            os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n"), L"&", pL->DimToString().c_str(), pR->DimToString().c_str());
+            throw ast::ScilabError(pMsg);
+        }
+        return pResult;
+    }
+}
+
+// ||
+InternalType* GenericShortcutOr(InternalType* _pL)
+{
+    InternalType* pResult = NULL;
+
+    if (_pL->isBool())
+    {
+        BoolOrBool(_pL->getAs<Bool>(), (Bool**)&pResult);
+    }
+
+    if (_pL->isInt())
+    {
+        IntOrInt(_pL, (Bool**)&pResult);
+    }
+
+    return pResult;
+}
+
+// |
+InternalType* GenericLogicalOr(InternalType* _pL, InternalType* _pR)
+{
+    InternalType* pResult = NULL;
+
+    if (_pL->isBool() && _pR->isBool())
+    {
+        Bool *pL = (Bool*)_pL;
+        Bool *pR = (Bool*)_pR;
+
+        int iResult = BoolLogicalOrBool(pL, pR, (Bool**)&pResult);
+        if (iResult != 0)
+        {
+            wchar_t pMsg[bsiz];
+            os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n"), L"|", pL->DimToString().c_str(), pR->DimToString().c_str());
+            throw ast::ScilabError(pMsg);
+        }
+        return pResult;
+    }
+
+    if (_pL->isInt() && _pR->isInt())
+    {
+        int iResult = IntLogicalOrInt(_pL, _pR, &pResult);
+        if (iResult != 0)
+        {
+            GenericType* pL = _pL->getAs<GenericType>();
+            GenericType* pR = _pR->getAs<GenericType>();
+            wchar_t pMsg[bsiz];
+            os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n"), L"|", pL->DimToString().c_str(), pR->DimToString().c_str());
+            throw ast::ScilabError(pMsg);
+        }
+        return pResult;
+    }
+}
+
+int BoolAndBool(Bool* _pL, Bool** _pOut)
+{
+    for (int i = 0 ; i < _pL->getSize() ; i++)
+    {
+        if (_pL->get(i) == 0)
+        {
+            //false && something -> false
+            *_pOut = new Bool(0);
+            return 0;
+        }
+    }
+
+    //call non shorcut opearion
+    *_pOut = NULL;
+    return 0;
+}
+
+int BoolOrBool(Bool* _pL, Bool** _pOut)
+{
+    for (int i = 0 ; i < _pL->getSize() ; i++)
+    {
+        if (_pL->get(i) == 0)
+        {
+            //call non shorcut opearion
+            *_pOut = NULL;
+            return 0;
+        }
+    }
+
+    *_pOut = new Bool(1); //true && something -> true
+    return 0;
+}
+
+template <class K>
+static int IntOrInt(K* _pL, Bool** _pOut)
+{
+    for (int i = 0 ; i < _pL->getSize() ; i++)
+    {
+        if (_pL->get(i) == 0)
+        {
+            //call non shorcut opearion
+            *_pOut = NULL;
+            return 0;
+        }
+    }
+
+    *_pOut = new Bool(1); //true && something -> true
+    return 0;
+}
+
+int IntOrInt(InternalType* _pL, Bool** _pOut)
+{
+    switch (_pL->getType())
+    {
+        case InternalType::RealInt8 :
+        {
+            return IntOrInt(_pL->getAs<Int8>(), _pOut);
+        }
+        case InternalType::RealUInt8 :
+        {
+            return IntOrInt(_pL->getAs<UInt8>(), _pOut);
+        }
+        case InternalType::RealInt16 :
+        {
+            return IntOrInt(_pL->getAs<Int16>(), _pOut);
+        }
+        case InternalType::RealUInt16 :
+        {
+            return IntOrInt(_pL->getAs<UInt16>(), _pOut);
+        }
+        case InternalType::RealInt32 :
+        {
+            return IntOrInt(_pL->getAs<Int32>(), _pOut);
+        }
+        case InternalType::RealUInt32 :
+        {
+            return IntOrInt(_pL->getAs<UInt32>(), _pOut);
+        }
+        case InternalType::RealInt64 :
+        {
+            return IntOrInt(_pL->getAs<Int64>(), _pOut);
+        }
+        case InternalType::RealUInt64 :
+        {
+            return IntOrInt(_pL->getAs<UInt64>(), _pOut);
+        }
+    }
+
+    return 3;
+}
+
+template <class K>
+static int IntAndInt(K* _pL, Bool** _pOut)
+{
+    for (int i = 0 ; i < _pL->getSize() ; i++)
+    {
+        if (_pL->get(i) == 0)
+        {
+            //false && something -> false
+            *_pOut = new Bool(0);
+            return 0;
+        }
+    }
+
+    //call non shorcut opearion
+    *_pOut = NULL;
+    return 0;
+}
+
+int IntAndInt(InternalType* _pL, Bool** _pOut)
+{
+    switch (_pL->getType())
+    {
+        case InternalType::RealInt8 :
+        {
+            return IntAndInt(_pL->getAs<Int8>(), _pOut);
+        }
+        case InternalType::RealUInt8 :
+        {
+            return IntAndInt(_pL->getAs<UInt8>(), _pOut);
+        }
+        case InternalType::RealInt16 :
+        {
+            return IntAndInt(_pL->getAs<Int16>(), _pOut);
+        }
+        case InternalType::RealUInt16 :
+        {
+            return IntAndInt(_pL->getAs<UInt16>(), _pOut);
+        }
+        case InternalType::RealInt32 :
+        {
+            return IntAndInt(_pL->getAs<Int32>(), _pOut);
+        }
+        case InternalType::RealUInt32 :
+        {
+            return IntAndInt(_pL->getAs<UInt32>(), _pOut);
+        }
+        case InternalType::RealInt64 :
+        {
+            return IntAndInt(_pL->getAs<Int64>(), _pOut);
+        }
+        case InternalType::RealUInt64 :
+        {
+            return IntAndInt(_pL->getAs<UInt64>(), _pOut);
+        }
+    }
+
+    return 3;
+}
+
+template <class K>
+static int IntLogicalAndInt(K* _pL, K* _pR, InternalType** _pOut)
+{
+    // left scalar bitwise and right matrix
+    if (_pL->isScalar())
+    {
+        K *pI = new K(_pR->getDims(), _pR->getDimsArray());
+        for (int i = 0 ; i < pI->getSize() ; i++)
+        {
+            pI->set(i, _pL->get(0) & _pR->get(i));
+        }
+
+        *_pOut = pI;
+        return 0;
+    }
+
+    // right scalar bitwise and left matrix
+    if (_pR->isScalar())
+    {
+        K *pI = new K(_pL->getDims(), _pL->getDimsArray());
+        for (int i = 0 ; i < pI->getSize() ; i++)
+        {
+            pI->set(i, _pR->get(0) & _pL->get(i));
+        }
+
+        *_pOut = pI;
+        return 0;
+    }
+
+    // check dims
+    if (_pL->getDims() != _pR->getDims())
+    {
+        return 1;
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0 ; i < _pL->getDims() ; i++)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            return 1;
+        }
+    }
+
+    // left matrix bitwise and right matrix
+    K* pI = new K(_pR->getDims(), _pR->getDimsArray());
+    for (int i = 0 ; i < _pL->getSize() ; i++)
+    {
+        pI->set(i, _pL->get(i) & _pR->get(i));
+    }
+
+    *_pOut = pI;
+    return 0;
+}
+
+int IntLogicalAndInt(InternalType* _pL, InternalType*  _pR, InternalType** _pOut)
+{
+    switch (_pL->getType())
+    {
+        case InternalType::RealInt8 :
+        {
+            return IntLogicalAndInt(_pL->getAs<Int8>(), _pR->getAs<Int8>(), _pOut);
+        }
+        case InternalType::RealUInt8 :
+        {
+            return IntLogicalAndInt(_pL->getAs<UInt8>(), _pR->getAs<UInt8>(), _pOut);
+        }
+        case InternalType::RealInt16 :
+        {
+            return IntLogicalAndInt(_pL->getAs<Int16>(), _pR->getAs<Int16>(), _pOut);
+        }
+        case InternalType::RealUInt16 :
+        {
+            return IntLogicalAndInt(_pL->getAs<UInt16>(), _pR->getAs<UInt16>(), _pOut);
+        }
+        case InternalType::RealInt32 :
+        {
+            return IntLogicalAndInt(_pL->getAs<Int32>(), _pR->getAs<Int32>(), _pOut);
+        }
+        case InternalType::RealUInt32 :
+        {
+            return IntLogicalAndInt(_pL->getAs<UInt32>(), _pR->getAs<UInt32>(), _pOut);
+        }
+        case InternalType::RealInt64 :
+        {
+            return IntLogicalAndInt(_pL->getAs<Int64>(), _pR->getAs<Int64>(), _pOut);
+        }
+        case InternalType::RealUInt64 :
+        {
+            return IntLogicalAndInt(_pL->getAs<UInt64>(), _pR->getAs<UInt64>(), _pOut);
+        }
+    }
+
+    return 3;
+}
+
+template <class K>
+static int IntLogicalOrInt(K* _pL, K* _pR, InternalType** _pOut)
+{
+    // left scalar bitwise or right matrix
+    if (_pL->isScalar())
+    {
+        K *pI = new K(_pR->getDims(), _pR->getDimsArray());
+        for (int i = 0 ; i < pI->getSize() ; i++)
+        {
+            pI->set(i, _pL->get(0) | _pR->get(i));
+        }
+
+        *_pOut = pI;
+        return 0;
+    }
+
+    // right scalar bitwise or left matrix
+    if (_pR->isScalar())
+    {
+        K *pI = new K(_pL->getDims(), _pL->getDimsArray());
+        for (int i = 0 ; i < pI->getSize() ; i++)
+        {
+            pI->set(i, _pR->get(0) | _pL->get(i));
+        }
+
+        *_pOut = pI;
+        return 0;
+    }
+
+    // check dims
+    if (_pL->getDims() != _pR->getDims())
+    {
+        return 1;
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0 ; i < _pL->getDims() ; i++)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            return 1;
+        }
+    }
+
+    // left matrix bitwise or right matrix
+    K* pI = new K(_pR->getDims(), _pR->getDimsArray());
+    for (int i = 0 ; i < _pL->getSize() ; i++)
+    {
+        pI->set(i, _pL->get(i) | _pR->get(i));
+    }
+
+    *_pOut = pI;
+    return 0;
+}
+
+int IntLogicalOrInt(InternalType* _pL, InternalType*  _pR, InternalType** _pOut)
+{
+    switch (_pL->getType())
+    {
+        case InternalType::RealInt8 :
+        {
+            Int8* pI1 = _pL->getAs<Int8>();
+            Int8* pI2 = _pR->getAs<Int8>();
+            return IntLogicalOrInt(pI1, pI2, _pOut);
+        }
+        case InternalType::RealUInt8 :
+        {
+            UInt8* pI1 = _pL->getAs<UInt8>();
+            UInt8* pI2 = _pR->getAs<UInt8>();
+            return IntLogicalOrInt(pI1, pI2, _pOut);
+        }
+        case InternalType::RealInt16 :
+        {
+            Int16* pI1 = _pL->getAs<Int16>();
+            Int16* pI2 = _pR->getAs<Int16>();
+            return IntLogicalOrInt(pI1, pI2, _pOut);
+        }
+        case InternalType::RealUInt16 :
+        {
+            UInt16* pI1 = _pL->getAs<UInt16>();
+            UInt16* pI2 = _pR->getAs<UInt16>();
+            return IntLogicalOrInt(pI1, pI2, _pOut);
+        }
+        case InternalType::RealInt32 :
+        {
+            Int32* pI1 = _pL->getAs<Int32>();
+            Int32* pI2 = _pR->getAs<Int32>();
+            return IntLogicalOrInt(pI1, pI2, _pOut);
+        }
+        case InternalType::RealUInt32 :
+        {
+            UInt32* pI1 = _pL->getAs<UInt32>();
+            UInt32* pI2 = _pR->getAs<UInt32>();
+            return IntLogicalOrInt(pI1, pI2, _pOut);
+        }
+        case InternalType::RealInt64 :
+        {
+            Int64* pI1 = _pL->getAs<Int64>();
+            Int64* pI2 = _pR->getAs<Int64>();
+            return IntLogicalOrInt(pI1, pI2, _pOut);
+        }
+        case InternalType::RealUInt64 :
+        {
+            UInt64* pI1 = _pL->getAs<UInt64>();
+            UInt64* pI2 = _pR->getAs<UInt64>();
+            return IntLogicalOrInt(pI1, pI2, _pOut);
+        }
+    }
+
+    return 3;
+}
+
+int BoolLogicalOrBool(Bool* _pL, Bool*  _pR, Bool** _pOut)
+{
+    int* piR = _pR->get();
+    int* piL = _pL->get();
+    int* piB = NULL;
+
+    // M | scalar
+    if (_pR->getSize() == 1)
+    {
+        *_pOut = new Bool(_pL->getRows(), _pL->getCols(), &piB);
+        for (int i = 0 ; i < _pL->getSize(); i++)
+        {
+            piB[i] = (piR[0] == 1) || (piL[i] == 1);
+        }
+
+        return 0;
+    }
+
+    if (_pL->getSize() == 1)
+    {
+        // scalar | M
+        *_pOut = new Bool(_pR->getRows(), _pR->getCols(), &piB);
+        for (int i = 0 ; i < _pR->getSize(); i++)
+        {
+            piB[i] = (piR[i] == 1) || (piL[0] == 1);
+        }
+
+        return 0;
+    }
+
+    if (_pR->getRows() == _pL->getRows() && _pR->getCols() == _pL->getCols())
+    {
+        // M | N (generic case)
+        *_pOut = new Bool(_pR->getRows(), _pR->getCols(), &piB);
+        for (int i = 0 ; i < _pL->getSize(); i++)
+        {
+            piB[i] = (piR[i] == 1) || (piL[i] == 1);
+        }
+
+        return 0;
+    }
+
+    return 1;
+}
+
+int BoolLogicalAndBool(Bool* _pL, Bool*  _pR, Bool** _pOut)
+{
+    int* piR = _pR->get();
+    int* piL = _pL->get();
+    int* piB = NULL;
+
+    // M & scalar
+    if (_pR->getSize() == 1)
+    {
+        *_pOut = new Bool(_pL->getRows(), _pL->getCols(), &piB);
+        for (int i = 0 ; i < _pL->getSize(); i++)
+        {
+            piB[i] = (piR[0] == 1) && (piL[i] == 1);
+        }
+
+        return 0;
+    }
+
+    if (_pL->getSize() == 1)
+    {
+        // scalar & M
+        *_pOut = new Bool(_pR->getRows(), _pR->getCols(), &piB);
+        for (int i = 0 ; i < _pR->getSize(); i++)
+        {
+            piB[i] = (piR[i] == 1) && (piL[0] == 1);
+        }
+
+        return 0;
+    }
+
+    if (_pR->getRows() == _pL->getRows() && _pR->getCols() == _pL->getCols())
+    {
+        // M & N (generic case)
+        *_pOut = new Bool(_pR->getRows(), _pR->getCols(), &piB);
+        for (int i = 0 ; i < _pL->getSize(); i++)
+        {
+            piB[i] = (piR[i] == 1) && (piL[i] == 1);
+        }
+
+        return 0;
+    }
+
+    return 1;
+}
+
diff --git a/scilab/modules/operations/tests/unit_tests/or_and.dia.ref b/scilab/modules/operations/tests/unit_tests/or_and.dia.ref
new file mode 100644 (file)
index 0000000..46f61e5
--- /dev/null
@@ -0,0 +1,372 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - DIGITEO - Antoine ELIAS
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+//
+// <-- JVM NOT MANDATORY -->
+false = %f;
+true = %t;
+//scalar AND scalar in operation
+assert_checkfalse(false & false);
+assert_checkfalse(false & true);
+assert_checkfalse(true & false);
+assert_checktrue(true & true);
+//scalar OR scalar in operation
+assert_checkfalse(false | false);
+assert_checktrue(false | true);
+assert_checktrue(true | false);
+assert_checktrue(true | true);
+//scalar AND scalar in condition
+if (false & false) <> false then bugmes();quit;end
+if (false & true) <> false then bugmes();quit;end
+if (true & false) <> false then bugmes();quit;end
+if (true & true) <> true then bugmes();quit;end
+//scalar OR scalar in condition
+if (false | false) <> false then bugmes();quit;end
+if (false | true) <> true then bugmes();quit;end
+if (true | false) <> true then bugmes();quit;end
+if (true | true) <> true then bugmes();quit;end
+MF = [false,false;false,false];
+MT = [true,true;true,true];
+//scalar AND matrix in operation
+assert_checkfalse(false & MF);
+assert_checkfalse(false & MT);
+assert_checkfalse(true & MF);
+assert_checktrue(true & MT);
+//scalar OR matrix in operation
+assert_checkfalse(false | MF);
+assert_checktrue(false | MT);
+assert_checktrue(true | MF);
+assert_checktrue(true | MT);
+//scalar AND matrix in condition
+if (false & MF) <> false then bugmes();quit;end
+if (false & MT) <> false then bugmes();quit;end
+if (true & MF) <> false then bugmes();quit;end
+if (true & MT) <> true then bugmes();quit;end
+//scalar OR matrix in condition
+if (false | MF) <> false then bugmes();quit;end
+if (false | MT) <> true then bugmes();quit;end
+if (true | MF) <> true then bugmes();quit;end
+if (true | MT) <> true then bugmes();quit;end
+//matrix AND scalar in operation
+assert_checkfalse(MF & false);
+assert_checkfalse(MF & true);
+assert_checkfalse(MT & false);
+assert_checktrue(MT & true);
+//matrix OR scalar in operation
+assert_checkfalse(MF | false);
+assert_checktrue(MF | true);
+assert_checktrue(MT | false);
+assert_checktrue(MT | true);
+//matrix AND scalar in condition
+if (MF & false) <> false then bugmes();quit;end
+if (MF & true) <> false then bugmes();quit;end
+if (MT & false) <> false then bugmes();quit;end
+if (MT & true) <> true then bugmes();quit;end
+//matrix OR scalar in condition
+if (MF | false) <> false then bugmes();quit;end
+if (MF | true) <> true then bugmes();quit;end
+if (MT | false) <> true then bugmes();quit;end
+if (MT | true) <> true then bugmes();quit;end
+//matrix AND matrix in operation
+assert_checkfalse(MF & MF);
+assert_checkfalse(MF & MT);
+assert_checkfalse(MT & MF);
+assert_checktrue(MT & MT);
+//matrix OR matrix in operation
+assert_checkfalse(MF | MF);
+assert_checktrue(MF | MT);
+assert_checktrue(MT | MF);
+assert_checktrue(MT | MT);
+//matrix AND matrix in condition
+if (MF & MF) <> MF then bugmes();quit;end
+if (MF & MT) <> MF then bugmes();quit;end
+if (MT & MF) <> MF then bugmes();quit;end
+if (MT & MT) <> MT then bugmes();quit;end
+//matrix OR matrix in condition
+if (MF | MF) <> MF then bugmes();quit;end
+if (MF | MT) <> MT then bugmes();quit;end
+if (MT | MF) <> MT then bugmes();quit;end
+if (MT | MT) <> MT then bugmes();quit;end
+//int | int
+b0 = int8(0);
+b1 = int8(1);
+b2 = int8(2);
+b3 = int8(4);
+b4 = int8(8);
+b12 = int8(3);
+b13 = int8(5);
+b14 = int8(9);
+b23 = int8(6);
+b24 = int8(10);
+b34 = int8(12);
+b123 = int8(7);
+b124 = int8(11);
+b134 = int8(13);
+b234 = int8(14);
+b1234 = int8(15);
+//scalar OR scalar in operation
+assert_checktrue((b0 | b0) == b0);
+assert_checktrue((b0 | b1) == b1);
+assert_checktrue((b0 | b2) == b2);
+assert_checktrue((b0 | b3) == b3);
+assert_checktrue((b0 | b4) == b4);
+assert_checktrue((b0 | b12) == b12);
+assert_checktrue((b0 | b13) == b13);
+assert_checktrue((b0 | b14) == b14);
+assert_checktrue((b0 | b23) == b23);
+assert_checktrue((b0 | b24) == b24);
+assert_checktrue((b0 | b34) == b34);
+assert_checktrue((b0 | b123) == b123);
+assert_checktrue((b0 | b134) == b134);
+assert_checktrue((b0 | b234) == b234);
+assert_checktrue((b0 | b1234) == b1234);
+assert_checktrue((b1 | b1) == b1);
+assert_checktrue((b1 | b2) == b12);
+assert_checktrue((b1 | b3) == b13);
+assert_checktrue((b1 | b4) == b14);
+assert_checktrue((b1 | b12) == b12);
+assert_checktrue((b1 | b13) == b13);
+assert_checktrue((b1 | b14) == b14);
+assert_checktrue((b1 | b23) == b123);
+assert_checktrue((b1 | b24) == b124);
+assert_checktrue((b1 | b34) == b134);
+assert_checktrue((b1 | b123) == b123);
+assert_checktrue((b1 | b134) == b134);
+assert_checktrue((b1 | b234) == b1234);
+assert_checktrue((b1 | b1234) == b1234);
+assert_checktrue((b2 | b2) == b2);
+assert_checktrue((b2 | b3) == b23);
+assert_checktrue((b2 | b4) == b24);
+assert_checktrue((b2 | b12) == b12);
+assert_checktrue((b2 | b13) == b123);
+assert_checktrue((b2 | b14) == b124);
+assert_checktrue((b2 | b23) == b23);
+assert_checktrue((b2 | b24) == b24);
+assert_checktrue((b2 | b34) == b234);
+assert_checktrue((b2 | b123) == b123);
+assert_checktrue((b2 | b134) == b1234);
+assert_checktrue((b2 | b234) == b234);
+assert_checktrue((b2 | b1234) == b1234);
+assert_checktrue((b3 | b3) == b3);
+assert_checktrue((b3 | b4) == b34);
+assert_checktrue((b3 | b12) == b123);
+assert_checktrue((b3 | b13) == b13);
+assert_checktrue((b3 | b14) == b134);
+assert_checktrue((b3 | b23) == b23);
+assert_checktrue((b3 | b24) == b234);
+assert_checktrue((b3 | b34) == b34);
+assert_checktrue((b3 | b123) == b123);
+assert_checktrue((b3 | b134) == b134);
+assert_checktrue((b3 | b234) == b234);
+assert_checktrue((b3 | b1234) == b1234);
+assert_checktrue((b4 | b4) == b4);
+assert_checktrue((b4 | b12) == b124);
+assert_checktrue((b4 | b13) == b134);
+assert_checktrue((b4 | b14) == b14);
+assert_checktrue((b4 | b23) == b234);
+assert_checktrue((b4 | b24) == b24);
+assert_checktrue((b4 | b34) == b34);
+assert_checktrue((b4 | b123) == b1234);
+assert_checktrue((b4 | b134) == b134);
+assert_checktrue((b4 | b234) == b234);
+assert_checktrue((b4 | b1234) == b1234);
+assert_checktrue((b12 | b12) == b12);
+assert_checktrue((b12 | b13) == b123);
+assert_checktrue((b12 | b14) == b124);
+assert_checktrue((b12 | b23) == b123);
+assert_checktrue((b12 | b24) == b124);
+assert_checktrue((b12 | b34) == b1234);
+assert_checktrue((b12 | b123) == b123);
+assert_checktrue((b12 | b134) == b1234);
+assert_checktrue((b12 | b234) == b1234);
+assert_checktrue((b12 | b1234) == b1234);
+assert_checktrue((b13 | b13) == b13);
+assert_checktrue((b13 | b14) == b134);
+assert_checktrue((b13 | b23) == b123);
+assert_checktrue((b13 | b24) == b1234);
+assert_checktrue((b13 | b34) == b134);
+assert_checktrue((b13 | b123) == b123);
+assert_checktrue((b13 | b134) == b134);
+assert_checktrue((b13 | b234) == b1234);
+assert_checktrue((b13 | b1234) == b1234);
+assert_checktrue((b14 | b14) == b14);
+assert_checktrue((b14 | b23) == b1234);
+assert_checktrue((b14 | b24) == b124);
+assert_checktrue((b14 | b34) == b134);
+assert_checktrue((b14 | b123) == b1234);
+assert_checktrue((b14 | b134) == b134);
+assert_checktrue((b14 | b234) == b1234);
+assert_checktrue((b14 | b1234) == b1234);
+assert_checktrue((b23 | b23) == b23);
+assert_checktrue((b23 | b24) == b234);
+assert_checktrue((b23 | b34) == b234);
+assert_checktrue((b23 | b123) == b123);
+assert_checktrue((b23 | b134) == b1234);
+assert_checktrue((b23 | b234) == b234);
+assert_checktrue((b23 | b1234) == b1234);
+assert_checktrue((b24 | b24) == b24);
+assert_checktrue((b24 | b34) == b234);
+assert_checktrue((b24 | b123) == b1234);
+assert_checktrue((b24 | b134) == b1234);
+assert_checktrue((b24 | b234) == b234);
+assert_checktrue((b24 | b1234) == b1234);
+assert_checktrue((b34 | b34) == b34);
+assert_checktrue((b34 | b123) == b1234);
+assert_checktrue((b34 | b134) == b134);
+assert_checktrue((b34 | b234) == b234);
+assert_checktrue((b34 | b1234) == b1234);
+assert_checktrue((b123 | b123) == b123);
+assert_checktrue((b123 | b134) == b1234);
+assert_checktrue((b123 | b234) == b1234);
+assert_checktrue((b123 | b1234) == b1234);
+assert_checktrue((b134 | b134) == b134);
+assert_checktrue((b134 | b234) == b1234);
+assert_checktrue((b134 | b1234) == b1234);
+assert_checktrue((b234 | b234) == b234);
+assert_checktrue((b234 | b1234) == b1234);
+assert_checktrue((b1234 | b1234) == b1234);
+//scalar AND scalar in operation
+assert_checktrue((b0 & b0) == b0);
+assert_checktrue((b0 & b1) == b0);
+assert_checktrue((b0 & b2) == b0);
+assert_checktrue((b0 & b3) == b0);
+assert_checktrue((b0 & b4) == b0);
+assert_checktrue((b0 & b12) == b0);
+assert_checktrue((b0 & b13) == b0);
+assert_checktrue((b0 & b14) == b0);
+assert_checktrue((b0 & b23) == b0);
+assert_checktrue((b0 & b24) == b0);
+assert_checktrue((b0 & b34) == b0);
+assert_checktrue((b0 & b123) == b0);
+assert_checktrue((b0 & b134) == b0);
+assert_checktrue((b0 & b234) == b0);
+assert_checktrue((b0 & b1234) == b0);
+assert_checktrue((b1 & b1) == b1);
+assert_checktrue((b1 & b2) == b0);
+assert_checktrue((b1 & b3) == b0);
+assert_checktrue((b1 & b4) == b0);
+assert_checktrue((b1 & b12) == b1);
+assert_checktrue((b1 & b13) == b1);
+assert_checktrue((b1 & b14) == b1);
+assert_checktrue((b1 & b23) == b0);
+assert_checktrue((b1 & b24) == b0);
+assert_checktrue((b1 & b34) == b0);
+assert_checktrue((b1 & b123) == b1);
+assert_checktrue((b1 & b134) == b1);
+assert_checktrue((b1 & b234) == b0);
+assert_checktrue((b1 & b1234) == b1);
+assert_checktrue((b2 & b2) == b2);
+assert_checktrue((b2 & b3) == b0);
+assert_checktrue((b2 & b4) == b0);
+assert_checktrue((b2 & b12) == b2);
+assert_checktrue((b2 & b13) == b0);
+assert_checktrue((b2 & b14) == b0);
+assert_checktrue((b2 & b23) == b2);
+assert_checktrue((b2 & b24) == b2);
+assert_checktrue((b2 & b34) == b0);
+assert_checktrue((b2 & b123) == b2);
+assert_checktrue((b2 & b134) == b0);
+assert_checktrue((b2 & b234) == b2);
+assert_checktrue((b2 & b1234) == b2);
+assert_checktrue((b3 & b3) == b3);
+assert_checktrue((b3 & b4) == b0);
+assert_checktrue((b3 & b12) == b0);
+assert_checktrue((b3 & b13) == b3);
+assert_checktrue((b3 & b14) == b0);
+assert_checktrue((b3 & b23) == b3);
+assert_checktrue((b3 & b24) == b0);
+assert_checktrue((b3 & b34) == b3);
+assert_checktrue((b3 & b123) == b3);
+assert_checktrue((b3 & b134) == b3);
+assert_checktrue((b3 & b234) == b3);
+assert_checktrue((b3 & b1234) == b3);
+assert_checktrue((b4 & b4) == b4);
+assert_checktrue((b4 & b12) == b0);
+assert_checktrue((b4 & b13) == b0);
+assert_checktrue((b4 & b14) == b4);
+assert_checktrue((b4 & b23) == b0);
+assert_checktrue((b4 & b24) == b4);
+assert_checktrue((b4 & b34) == b4);
+assert_checktrue((b4 & b123) == b0);
+assert_checktrue((b4 & b134) == b4);
+assert_checktrue((b4 & b234) == b4);
+assert_checktrue((b4 & b1234) == b4);
+assert_checktrue((b12 & b12) == b12);
+assert_checktrue((b12 & b13) == b1);
+assert_checktrue((b12 & b14) == b1);
+assert_checktrue((b12 & b23) == b2);
+assert_checktrue((b12 & b24) == b2);
+assert_checktrue((b12 & b34) == b0);
+assert_checktrue((b12 & b123) == b12);
+assert_checktrue((b12 & b134) == b1);
+assert_checktrue((b12 & b234) == b2);
+assert_checktrue((b12 & b1234) == b12);
+assert_checktrue((b13 & b13) == b13);
+assert_checktrue((b13 & b14) == b1);
+assert_checktrue((b13 & b23) == b3);
+assert_checktrue((b13 & b24) == b0);
+assert_checktrue((b13 & b34) == b3);
+assert_checktrue((b13 & b123) == b13);
+assert_checktrue((b13 & b134) == b13);
+assert_checktrue((b13 & b234) == b3);
+assert_checktrue((b13 & b1234) == b13);
+assert_checktrue((b14 & b14) == b14);
+assert_checktrue((b14 & b23) == b0);
+assert_checktrue((b14 & b24) == b4);
+assert_checktrue((b14 & b34) == b4);
+assert_checktrue((b14 & b123) == b1);
+assert_checktrue((b14 & b134) == b14);
+assert_checktrue((b14 & b234) == b4);
+assert_checktrue((b14 & b1234) == b14);
+assert_checktrue((b23 & b23) == b23);
+assert_checktrue((b23 & b24) == b2);
+assert_checktrue((b23 & b34) == b3);
+assert_checktrue((b23 & b123) == b23);
+assert_checktrue((b23 & b134) == b3);
+assert_checktrue((b23 & b234) == b23);
+assert_checktrue((b23 & b1234) == b23);
+assert_checktrue((b24 & b24) == b24);
+assert_checktrue((b24 & b34) == b4);
+assert_checktrue((b24 & b123) == b2);
+assert_checktrue((b24 & b134) == b4);
+assert_checktrue((b24 & b234) == b24);
+assert_checktrue((b24 & b1234) == b24);
+assert_checktrue((b34 & b34) == b34);
+assert_checktrue((b34 & b123) == b3);
+assert_checktrue((b34 & b134) == b34);
+assert_checktrue((b34 & b234) == b34);
+assert_checktrue((b34 & b1234) == b34);
+assert_checktrue((b123 & b123) == b123);
+assert_checktrue((b123 & b134) == b13);
+assert_checktrue((b123 & b234) == b23);
+assert_checktrue((b123 & b1234) == b123);
+assert_checktrue((b134 & b134) == b134);
+assert_checktrue((b134 & b234) == b34);
+assert_checktrue((b134 & b1234) == b134);
+assert_checktrue((b234 & b234) == b234);
+assert_checktrue((b234 & b1234) == b234);
+assert_checktrue((b1234 & b1234) == b1234);
+//scalar OR scalar in condition
+if b0 | b0 then bugmes();quit;end
+//others case returns true and we do not want to test with '=='
+//scalar AND scalar in condition
+if b0 & b0 then bugmes();quit;end
+if b0 & b1 then bugmes();quit;end
+if b0 & b2 then bugmes();quit;end
+if b0 & b3 then bugmes();quit;end
+if b0 & b4 then bugmes();quit;end
+if b0 & b12 then bugmes();quit;end
+if b0 & b13 then bugmes();quit;end
+if b0 & b14 then bugmes();quit;end
+if b0 & b23 then bugmes();quit;end
+if b0 & b24 then bugmes();quit;end
+if b0 & b34 then bugmes();quit;end
+if b0 & b123 then bugmes();quit;end
+if b0 & b124 then bugmes();quit;end
+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 '=='
diff --git a/scilab/modules/operations/tests/unit_tests/or_and.tst b/scilab/modules/operations/tests/unit_tests/or_and.tst
new file mode 100644 (file)
index 0000000..1bfa8fa
--- /dev/null
@@ -0,0 +1,429 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - DIGITEO - Antoine ELIAS
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+//
+// <-- JVM NOT MANDATORY -->
+
+false = %f;
+true = %t;
+
+
+//scalar AND scalar in operation
+assert_checkfalse(false & false);
+assert_checkfalse(false & true);
+assert_checkfalse(true & false);
+assert_checktrue(true & true);
+
+//scalar OR scalar in operation
+assert_checkfalse(false | false);
+assert_checktrue(false | true);
+assert_checktrue(true | false);
+assert_checktrue(true | true);
+
+//scalar AND scalar in condition
+if (false & false) <> false then pause; end
+if (false & true) <> false then pause; end
+if (true & false) <> false then pause; end
+if (true & true) <> true then pause; end
+
+//scalar OR scalar in condition
+if (false | false) <> false then pause; end
+if (false | true) <> true then pause; end
+if (true | false) <> true then pause; end
+if (true | true) <> true then pause; end
+
+
+MF = [false,false;false,false];
+MT = [true,true;true,true];
+
+//scalar AND matrix in operation
+assert_checkfalse(false & MF);
+assert_checkfalse(false & MT);
+assert_checkfalse(true & MF);
+assert_checktrue(true & MT);
+
+//scalar OR matrix in operation
+assert_checkfalse(false | MF);
+assert_checktrue(false | MT);
+assert_checktrue(true | MF);
+assert_checktrue(true | MT);
+
+//scalar AND matrix in condition
+if (false & MF) <> false then pause; end
+if (false & MT) <> false then pause; end
+if (true & MF) <> false then pause; end
+if (true & MT) <> true then pause; end
+
+//scalar OR matrix in condition
+if (false | MF) <> false then pause; end
+if (false | MT) <> true then pause; end
+if (true | MF) <> true then pause; end
+if (true | MT) <> true then pause; end
+
+//matrix AND scalar in operation
+assert_checkfalse(MF & false);
+assert_checkfalse(MF & true);
+assert_checkfalse(MT & false);
+assert_checktrue(MT & true);
+
+//matrix OR scalar in operation
+assert_checkfalse(MF | false);
+assert_checktrue(MF | true);
+assert_checktrue(MT | false);
+assert_checktrue(MT | true);
+
+//matrix AND scalar in condition
+if (MF & false) <> false then pause; end
+if (MF & true) <> false then pause; end
+if (MT & false) <> false then pause; end
+if (MT & true) <> true then pause; end
+
+//matrix OR scalar in condition
+if (MF | false) <> false then pause; end
+if (MF | true) <> true then pause; end
+if (MT | false) <> true then pause; end
+if (MT | true) <> true then pause; end
+
+//matrix AND matrix in operation
+assert_checkfalse(MF & MF);
+assert_checkfalse(MF & MT);
+assert_checkfalse(MT & MF);
+assert_checktrue(MT & MT);
+
+//matrix OR matrix in operation
+assert_checkfalse(MF | MF);
+assert_checktrue(MF | MT);
+assert_checktrue(MT | MF);
+assert_checktrue(MT | MT);
+
+//matrix AND matrix in condition
+if (MF & MF) <> MF then pause; end
+if (MF & MT) <> MF then pause; end
+if (MT & MF) <> MF then pause; end
+if (MT & MT) <> MT then pause; end
+
+//matrix OR matrix in condition
+if (MF | MF) <> MF then pause; end
+if (MF | MT) <> MT then pause; end
+if (MT | MF) <> MT then pause; end
+if (MT | MT) <> MT then pause; end
+
+
+//int | int
+b0 = int8(0);
+b1 = int8(1);
+b2 = int8(2);
+b3 = int8(4);
+b4 = int8(8);
+
+b12 = int8(3);
+b13 = int8(5);
+b14 = int8(9);
+b23 = int8(6);
+b24 = int8(10);
+b34 = int8(12);
+
+b123 = int8(7);
+b124 = int8(11);
+b134 = int8(13);
+b234 = int8(14);
+b1234 = int8(15);
+
+//scalar OR scalar in operation
+assert_checktrue((b0 | b0) == b0);
+assert_checktrue((b0 | b1) == b1);
+assert_checktrue((b0 | b2) == b2);
+assert_checktrue((b0 | b3) == b3);
+assert_checktrue((b0 | b4) == b4);
+assert_checktrue((b0 | b12) == b12);
+assert_checktrue((b0 | b13) == b13);
+assert_checktrue((b0 | b14) == b14);
+assert_checktrue((b0 | b23) == b23);
+assert_checktrue((b0 | b24) == b24);
+assert_checktrue((b0 | b34) == b34);
+assert_checktrue((b0 | b123) == b123);
+assert_checktrue((b0 | b134) == b134);
+assert_checktrue((b0 | b234) == b234);
+assert_checktrue((b0 | b1234) == b1234);
+
+assert_checktrue((b1 | b1) == b1);
+assert_checktrue((b1 | b2) == b12);
+assert_checktrue((b1 | b3) == b13);
+assert_checktrue((b1 | b4) == b14);
+assert_checktrue((b1 | b12) == b12);
+assert_checktrue((b1 | b13) == b13);
+assert_checktrue((b1 | b14) == b14);
+assert_checktrue((b1 | b23) == b123);
+assert_checktrue((b1 | b24) == b124);
+assert_checktrue((b1 | b34) == b134);
+assert_checktrue((b1 | b123) == b123);
+assert_checktrue((b1 | b134) == b134);
+assert_checktrue((b1 | b234) == b1234);
+assert_checktrue((b1 | b1234) == b1234);
+
+assert_checktrue((b2 | b2) == b2);
+assert_checktrue((b2 | b3) == b23);
+assert_checktrue((b2 | b4) == b24);
+assert_checktrue((b2 | b12) == b12);
+assert_checktrue((b2 | b13) == b123);
+assert_checktrue((b2 | b14) == b124);
+assert_checktrue((b2 | b23) == b23);
+assert_checktrue((b2 | b24) == b24);
+assert_checktrue((b2 | b34) == b234);
+assert_checktrue((b2 | b123) == b123);
+assert_checktrue((b2 | b134) == b1234);
+assert_checktrue((b2 | b234) == b234);
+assert_checktrue((b2 | b1234) == b1234);
+
+assert_checktrue((b3 | b3) == b3);
+assert_checktrue((b3 | b4) == b34);
+assert_checktrue((b3 | b12) == b123);
+assert_checktrue((b3 | b13) == b13);
+assert_checktrue((b3 | b14) == b134);
+assert_checktrue((b3 | b23) == b23);
+assert_checktrue((b3 | b24) == b234);
+assert_checktrue((b3 | b34) == b34);
+assert_checktrue((b3 | b123) == b123);
+assert_checktrue((b3 | b134) == b134);
+assert_checktrue((b3 | b234) == b234);
+assert_checktrue((b3 | b1234) == b1234);
+
+assert_checktrue((b4 | b4) == b4);
+assert_checktrue((b4 | b12) == b124);
+assert_checktrue((b4 | b13) == b134);
+assert_checktrue((b4 | b14) == b14);
+assert_checktrue((b4 | b23) == b234);
+assert_checktrue((b4 | b24) == b24);
+assert_checktrue((b4 | b34) == b34);
+assert_checktrue((b4 | b123) == b1234);
+assert_checktrue((b4 | b134) == b134);
+assert_checktrue((b4 | b234) == b234);
+assert_checktrue((b4 | b1234) == b1234);
+
+assert_checktrue((b12 | b12) == b12);
+assert_checktrue((b12 | b13) == b123);
+assert_checktrue((b12 | b14) == b124);
+assert_checktrue((b12 | b23) == b123);
+assert_checktrue((b12 | b24) == b124);
+assert_checktrue((b12 | b34) == b1234);
+assert_checktrue((b12 | b123) == b123);
+assert_checktrue((b12 | b134) == b1234);
+assert_checktrue((b12 | b234) == b1234);
+assert_checktrue((b12 | b1234) == b1234);
+
+assert_checktrue((b13 | b13) == b13);
+assert_checktrue((b13 | b14) == b134);
+assert_checktrue((b13 | b23) == b123);
+assert_checktrue((b13 | b24) == b1234);
+assert_checktrue((b13 | b34) == b134);
+assert_checktrue((b13 | b123) == b123);
+assert_checktrue((b13 | b134) == b134);
+assert_checktrue((b13 | b234) == b1234);
+assert_checktrue((b13 | b1234) == b1234);
+
+assert_checktrue((b14 | b14) == b14);
+assert_checktrue((b14 | b23) == b1234);
+assert_checktrue((b14 | b24) == b124);
+assert_checktrue((b14 | b34) == b134);
+assert_checktrue((b14 | b123) == b1234);
+assert_checktrue((b14 | b134) == b134);
+assert_checktrue((b14 | b234) == b1234);
+assert_checktrue((b14 | b1234) == b1234);
+
+assert_checktrue((b23 | b23) == b23);
+assert_checktrue((b23 | b24) == b234);
+assert_checktrue((b23 | b34) == b234);
+assert_checktrue((b23 | b123) == b123);
+assert_checktrue((b23 | b134) == b1234);
+assert_checktrue((b23 | b234) == b234);
+assert_checktrue((b23 | b1234) == b1234);
+
+assert_checktrue((b24 | b24) == b24);
+assert_checktrue((b24 | b34) == b234);
+assert_checktrue((b24 | b123) == b1234);
+assert_checktrue((b24 | b134) == b1234);
+assert_checktrue((b24 | b234) == b234);
+assert_checktrue((b24 | b1234) == b1234);
+
+assert_checktrue((b34 | b34) == b34);
+assert_checktrue((b34 | b123) == b1234);
+assert_checktrue((b34 | b134) == b134);
+assert_checktrue((b34 | b234) == b234);
+assert_checktrue((b34 | b1234) == b1234);
+
+assert_checktrue((b123 | b123) == b123);
+assert_checktrue((b123 | b134) == b1234);
+assert_checktrue((b123 | b234) == b1234);
+assert_checktrue((b123 | b1234) == b1234);
+
+assert_checktrue((b134 | b134) == b134);
+assert_checktrue((b134 | b234) == b1234);
+assert_checktrue((b134 | b1234) == b1234);
+
+assert_checktrue((b234 | b234) == b234);
+assert_checktrue((b234 | b1234) == b1234);
+
+assert_checktrue((b1234 | b1234) == b1234);
+
+//scalar AND scalar in operation
+assert_checktrue((b0 & b0) == b0);
+assert_checktrue((b0 & b1) == b0);
+assert_checktrue((b0 & b2) == b0);
+assert_checktrue((b0 & b3) == b0);
+assert_checktrue((b0 & b4) == b0);
+assert_checktrue((b0 & b12) == b0);
+assert_checktrue((b0 & b13) == b0);
+assert_checktrue((b0 & b14) == b0);
+assert_checktrue((b0 & b23) == b0);
+assert_checktrue((b0 & b24) == b0);
+assert_checktrue((b0 & b34) == b0);
+assert_checktrue((b0 & b123) == b0);
+assert_checktrue((b0 & b134) == b0);
+assert_checktrue((b0 & b234) == b0);
+assert_checktrue((b0 & b1234) == b0);
+
+assert_checktrue((b1 & b1) == b1);
+assert_checktrue((b1 & b2) == b0);
+assert_checktrue((b1 & b3) == b0);
+assert_checktrue((b1 & b4) == b0);
+assert_checktrue((b1 & b12) == b1);
+assert_checktrue((b1 & b13) == b1);
+assert_checktrue((b1 & b14) == b1);
+assert_checktrue((b1 & b23) == b0);
+assert_checktrue((b1 & b24) == b0);
+assert_checktrue((b1 & b34) == b0);
+assert_checktrue((b1 & b123) == b1);
+assert_checktrue((b1 & b134) == b1);
+assert_checktrue((b1 & b234) == b0);
+assert_checktrue((b1 & b1234) == b1);
+
+assert_checktrue((b2 & b2) == b2);
+assert_checktrue((b2 & b3) == b0);
+assert_checktrue((b2 & b4) == b0);
+assert_checktrue((b2 & b12) == b2);
+assert_checktrue((b2 & b13) == b0);
+assert_checktrue((b2 & b14) == b0);
+assert_checktrue((b2 & b23) == b2);
+assert_checktrue((b2 & b24) == b2);
+assert_checktrue((b2 & b34) == b0);
+assert_checktrue((b2 & b123) == b2);
+assert_checktrue((b2 & b134) == b0);
+assert_checktrue((b2 & b234) == b2);
+assert_checktrue((b2 & b1234) == b2);
+
+assert_checktrue((b3 & b3) == b3);
+assert_checktrue((b3 & b4) == b0);
+assert_checktrue((b3 & b12) == b0);
+assert_checktrue((b3 & b13) == b3);
+assert_checktrue((b3 & b14) == b0);
+assert_checktrue((b3 & b23) == b3);
+assert_checktrue((b3 & b24) == b0);
+assert_checktrue((b3 & b34) == b3);
+assert_checktrue((b3 & b123) == b3);
+assert_checktrue((b3 & b134) == b3);
+assert_checktrue((b3 & b234) == b3);
+assert_checktrue((b3 & b1234) == b3);
+
+assert_checktrue((b4 & b4) == b4);
+assert_checktrue((b4 & b12) == b0);
+assert_checktrue((b4 & b13) == b0);
+assert_checktrue((b4 & b14) == b4);
+assert_checktrue((b4 & b23) == b0);
+assert_checktrue((b4 & b24) == b4);
+assert_checktrue((b4 & b34) == b4);
+assert_checktrue((b4 & b123) == b0);
+assert_checktrue((b4 & b134) == b4);
+assert_checktrue((b4 & b234) == b4);
+assert_checktrue((b4 & b1234) == b4);
+
+assert_checktrue((b12 & b12) == b12);
+assert_checktrue((b12 & b13) == b1);
+assert_checktrue((b12 & b14) == b1);
+assert_checktrue((b12 & b23) == b2);
+assert_checktrue((b12 & b24) == b2);
+assert_checktrue((b12 & b34) == b0);
+assert_checktrue((b12 & b123) == b12);
+assert_checktrue((b12 & b134) == b1);
+assert_checktrue((b12 & b234) == b2);
+assert_checktrue((b12 & b1234) == b12);
+
+assert_checktrue((b13 & b13) == b13);
+assert_checktrue((b13 & b14) == b1);
+assert_checktrue((b13 & b23) == b3);
+assert_checktrue((b13 & b24) == b0);
+assert_checktrue((b13 & b34) == b3);
+assert_checktrue((b13 & b123) == b13);
+assert_checktrue((b13 & b134) == b13);
+assert_checktrue((b13 & b234) == b3);
+assert_checktrue((b13 & b1234) == b13);
+
+assert_checktrue((b14 & b14) == b14);
+assert_checktrue((b14 & b23) == b0);
+assert_checktrue((b14 & b24) == b4);
+assert_checktrue((b14 & b34) == b4);
+assert_checktrue((b14 & b123) == b1);
+assert_checktrue((b14 & b134) == b14);
+assert_checktrue((b14 & b234) == b4);
+assert_checktrue((b14 & b1234) == b14);
+
+assert_checktrue((b23 & b23) == b23);
+assert_checktrue((b23 & b24) == b2);
+assert_checktrue((b23 & b34) == b3);
+assert_checktrue((b23 & b123) == b23);
+assert_checktrue((b23 & b134) == b3);
+assert_checktrue((b23 & b234) == b23);
+assert_checktrue((b23 & b1234) == b23);
+
+assert_checktrue((b24 & b24) == b24);
+assert_checktrue((b24 & b34) == b4);
+assert_checktrue((b24 & b123) == b2);
+assert_checktrue((b24 & b134) == b4);
+assert_checktrue((b24 & b234) == b24);
+assert_checktrue((b24 & b1234) == b24);
+
+assert_checktrue((b34 & b34) == b34);
+assert_checktrue((b34 & b123) == b3);
+assert_checktrue((b34 & b134) == b34);
+assert_checktrue((b34 & b234) == b34);
+assert_checktrue((b34 & b1234) == b34);
+
+assert_checktrue((b123 & b123) == b123);
+assert_checktrue((b123 & b134) == b13);
+assert_checktrue((b123 & b234) == b23);
+assert_checktrue((b123 & b1234) == b123);
+
+assert_checktrue((b134 & b134) == b134);
+assert_checktrue((b134 & b234) == b34);
+assert_checktrue((b134 & b1234) == b134);
+
+assert_checktrue((b234 & b234) == b234);
+assert_checktrue((b234 & b1234) == b234);
+
+assert_checktrue((b1234 & b1234) == b1234);
+
+//scalar OR scalar in condition
+if b0 | b0 then pause; end
+
+//others case returns true and we do not want to test with '=='
+
+//scalar AND scalar in condition
+if b0 & b0 then pause; end
+if b0 & b1 then pause; end
+if b0 & b2 then pause; end
+if b0 & b3 then pause; end
+if b0 & b4 then pause; end
+if b0 & b12 then pause; end
+if b0 & b13 then pause; end
+if b0 & b14 then pause; end
+if b0 & b23 then pause; end
+if b0 & b24 then pause; end
+if b0 & b34 then pause; end
+if b0 & b123 then pause; end
+if b0 & b124 then pause; end
+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 '=='
index 00a9a9f..4a226ed 100644 (file)
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
@@ -289,9 +289,6 @@ lib /DEF:"$(ProjectDir)operations_Import.def" /SUBSYSTEM:WINDOWS /MACHINE:$(Plat
     <Library Include="..\..\bin\libintl.lib" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\libs\dynamiclibrary\dynamiclibrary.vcxproj">
-      <Project>{77154919-8a20-4f35-b7c7-6b3b957bdca1}</Project>
-    </ProjectReference>
     <ProjectReference Include="..\ast\ast-tools\ast-tools.vcxproj">
       <Project>{1f4a0344-99ed-461b-bd53-1593788fb34d}</Project>
     </ProjectReference>