#3403 vtk8itk5wx3-macos

[bbtk.git] / packages / std / src / bbstdMathOperationVector.cxx

diff --git a/packages/std/src/bbstdMathOperationVector.cxx b/packages/std/src/bbstdMathOperationVector.cxx
index 2fc5d4ebd832be976b5ac26f780693645c7593dc..cbd934fd015f4d523779927973fd25aa5b2eaa46 100644 (file)
--- a/packages/std/src/bbstdMathOperationVector.cxx
+++ b/packages/std/src/bbstdMathOperationVector.cxx
@@ -5,7 +5,6 @@
 #include "bbstdPackage.h"
 
 #include <math.h>
-#include <stdlib.h>
 #include <time.h>
 
 namespace bbstd
@@ -50,7 +49,7 @@ void MathOperationVector::MinVector(std::vector<double> *v,std::vector<double> *
                tmpResult=(*v)[0];
                for (i=1;i<sizeVec;i++) 
                { 
-                       tmpResult = fmin ( (*v)[i] , tmpResult ) ; 
+                       tmpResult = std::min ( (*v)[i] , tmpResult ) ; 
                } // for i 
                vr->push_back( tmpResult ); 
        } // if sizeVec
@@ -67,7 +66,7 @@ void MathOperationVector::MaxVector(std::vector<double> *v,std::vector<double> *
                tmpResult=(*v)[0];
                for (i=1;i<sizeVec;i++) 
                { 
-                       tmpResult = fmax ( (*v)[i] , tmpResult ) ; 
+                       tmpResult = std::max ( (*v)[i] , tmpResult ) ; 
                } // for i 
                vr->push_back( tmpResult ); 
        } // if sizeVec
@@ -117,8 +116,8 @@ void MathOperationVector::Process()
        std::vector<double> *v8 = &_v8;
        std::vector<double> *v9 = &_v9;
 
-       double minTmp;          
-       double maxTmp;          
+       double minTmp;
+       double maxTmp;
 
         if (firsttime==true)
         {
@@ -335,15 +334,15 @@ void MathOperationVector::Process()
        {
                for (i=0;i<sizeVec;i++)
                {
-                       minTmp = fmin(  g(v0,i,999999) , g(v1,i,999999) );
-                       minTmp = fmin(  g(v2,i,999999) , minTmp );
-                       minTmp = fmin(  g(v3,i,999999) , minTmp );
-                       minTmp = fmin(  g(v4,i,999999) , minTmp );
-                       minTmp = fmin(  g(v5,i,999999) , minTmp );
-                       minTmp = fmin(  g(v6,i,999999) , minTmp );
-                       minTmp = fmin(  g(v7,i,999999) , minTmp );
-                       minTmp = fmin(  g(v8,i,999999) , minTmp );
-                       minTmp = fmin(  g(v9,i,999999) , minTmp );
+                       minTmp = std::min(  g(v0,i,999999) , g(v1,i,999999) );
+                       minTmp = std::min(  g(v2,i,999999) , minTmp );
+                       minTmp = std::min(  g(v3,i,999999) , minTmp );
+                       minTmp = std::min(  g(v4,i,999999) , minTmp );
+                       minTmp = std::min(  g(v5,i,999999) , minTmp );
+                       minTmp = std::min(  g(v6,i,999999) , minTmp );
+                       minTmp = std::min(  g(v7,i,999999) , minTmp );
+                       minTmp = std::min(  g(v8,i,999999) , minTmp );
+                       minTmp = std::min(  g(v9,i,999999) , minTmp );
                        resultVec.push_back( minTmp );
                } // for i
                bbSetOutputOut( resultVec );
@@ -369,15 +368,15 @@ void MathOperationVector::Process()
        {
                for (i=0;i<sizeVec;i++)
                {
-                       maxTmp = fmax(  g(v0,i,-999999) , g(v1,i,-999999) );
-                       maxTmp = fmax(  g(v2,i,-999999) , maxTmp );
-                       maxTmp = fmax(  g(v3,i,-999999) , maxTmp );
-                       maxTmp = fmax(  g(v4,i,-999999) , maxTmp );
-                       maxTmp = fmax(  g(v5,i,-999999) , maxTmp );
-                       maxTmp = fmax(  g(v6,i,-999999) , maxTmp );
-                       maxTmp = fmax(  g(v7,i,-999999) , maxTmp );
-                       maxTmp = fmax(  g(v8,i,-999999) , maxTmp );
-                       maxTmp = fmax(  g(v9,i,-999999) , maxTmp );
+                       maxTmp = std::max(  g(v0,i,-999999) , g(v1,i,-999999) );
+                       maxTmp = std::max(  g(v2,i,-999999) , maxTmp );
+                       maxTmp = std::max(  g(v3,i,-999999) , maxTmp );
+                       maxTmp = std::max(  g(v4,i,-999999) , maxTmp );
+                       maxTmp = std::max(  g(v5,i,-999999) , maxTmp );
+                       maxTmp = std::max(  g(v6,i,-999999) , maxTmp );
+                       maxTmp = std::max(  g(v7,i,-999999) , maxTmp );
+                       maxTmp = std::max(  g(v8,i,-999999) , maxTmp );
+                       maxTmp = std::max(  g(v9,i,-999999) , maxTmp );
                        resultVec.push_back(  maxTmp  );
                } // for i
                bbSetOutputOut( resultVec );
@@ -409,6 +408,111 @@ void MathOperationVector::Process()
                bbSetOutputOut( resultVec );
        } // Type 18
 
+    if (bbGetInputType()==19)
+       {
+               for (i=0;i<sizeVec;i++)
+               {
+                       resultVec.push_back(   (int)bbGetInputIn0()[i] % (int)bbGetInputIn1()[i]   );
+               } // for i
+               bbSetOutputOut( resultVec );
+       } // Type 19
+
+    if (bbGetInputType()==20)
+       {
+               for (i=0;i<sizeVec;i++)
+               {
+                       if (bbGetInputIn0()[i] < bbGetInputIn1()[i])
+                       {
+                               resultVec.push_back( 1 );
+                       } else {
+                               resultVec.push_back( 0 );
+                       }
+               } // for i
+               bbSetOutputOut( resultVec );
+       } // Type 20
+
+    if (bbGetInputType()==21)
+       {
+               for (i=0;i<sizeVec;i++)
+               {
+                       if (bbGetInputIn0()[i] > bbGetInputIn1()[i])
+                       {
+                               resultVec.push_back( 1 );
+                       } else {
+                               resultVec.push_back( 0 );
+                       }
+               } // for i
+               bbSetOutputOut( resultVec );
+       } // Type 21
+
+
+    if (bbGetInputType()==22) 
+       {
+               double resultX=0;
+               double resultY=0;
+               double resultZ=0;
+               double resultMassTotal=0;
+               for (i=0;i<sizeVec;i++)
+               {
+                       resultX                 = resultX + g(v0,i,0)*g(v3,i,1);
+                       resultY                 = resultY + g(v1,i,0)*g(v3,i,1);
+                       resultZ                 = resultZ + g(v2,i,0)*g(v3,i,1);
+                       resultMassTotal = resultMassTotal + g(v3,i,1);
+               } // for i
+               if (resultMassTotal!=0) 
+               {
+                       resultVec.push_back( resultX / resultMassTotal );
+                       resultVec.push_back( resultY / resultMassTotal );
+                       resultVec.push_back( resultZ / resultMassTotal );
+               } // if resultMassTotal
+               bbSetOutputOut( resultVec );
+       } // if Type 22
+
+
+    if (bbGetInputType()==23)
+       {
+               for (i=0;i<sizeVec;i++)
+               {
+                       resultVec.push_back(  round(  bbGetInputIn0()[i] )  );
+               } // for i
+               bbSetOutputOut( resultVec );
+       } // Type 23
+
+    if (bbGetInputType()==24)
+       {
+               for (i=0;i<sizeVec;i++)
+               {
+                       resultVec.push_back(  rint(  bbGetInputIn0()[i] )  );
+               } // for i
+               bbSetOutputOut( resultVec );
+       } // Type 24
+
+    if (bbGetInputType()==25)
+       {
+               for (i=0;i<sizeVec;i++)
+               {
+                       resultVec.push_back(  floor(  bbGetInputIn0()[i] )  );
+               } // for i
+               bbSetOutputOut( resultVec );
+       } // Type 25
+
+    if (bbGetInputType()==26)
+       {
+               for (i=0;i<sizeVec;i++)
+               {
+                       resultVec.push_back(  ceil(  bbGetInputIn0()[i] )  );
+               } // for i
+               bbSetOutputOut( resultVec );
+       } // Type 26
+
+    if (bbGetInputType()==27)
+       {
+               for (i=0;i<sizeVec;i++)
+               {
+                       resultVec.push_back(  trunc(  bbGetInputIn0()[i] )  );
+               } // for i
+               bbSetOutputOut( resultVec );
+       } // Type 27
 
 }