LCOV - code coverage report
Current view: top level - sc/source/core/opencl - op_database.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1226 0.0 %
Date: 2014-04-14 Functions: 0 11 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  */
       9             : 
      10             : #include "op_database.hxx"
      11             : 
      12             : #include "formulagroup.hxx"
      13             : #include "document.hxx"
      14             : #include "formulacell.hxx"
      15             : #include "tokenarray.hxx"
      16             : #include "compiler.hxx"
      17             : #include "interpre.hxx"
      18             : #include "formula/vectortoken.hxx"
      19             : #include <sstream>
      20             : 
      21             : 
      22             : namespace sc { namespace opencl {
      23             : 
      24           0 : void OpDmax::GenSlidingWindowFunction(std::stringstream &ss,
      25             :             const std::string &sSymName, SubArguments &vSubArguments)
      26             : {
      27           0 :     ss << "\ndouble " << sSymName;
      28           0 :     ss << "_"<< BinFuncName() <<"(";
      29           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
      30             :     {
      31           0 :         if (i)
      32           0 :             ss << ",";
      33           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
      34             :     }
      35           0 :     ss << ")\n    {\n";
      36           0 :     ss << "    int gid0=get_global_id(0);\n";
      37           0 :     ss << "    double max = -1000000000000;\n";
      38           0 :     ss << "    double value=0.0;\n";
      39           0 :     GenTmpVariables(ss,vSubArguments);
      40           0 :     int dataCol = 0;
      41           0 :     int dataRow = 0;
      42           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
      43             :     formula::svDoubleVectorRef)
      44             :     {
      45           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
      46             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
      47           0 :             formula::DoubleVectorRefToken *>(tmpCur);
      48           0 :         dataCol = pCurDVR1->GetArrays().size();
      49           0 :         dataRow = pCurDVR1->GetArrayLength();
      50             :     }
      51             :     else
      52           0 :         throw Unhandled();
      53           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
      54             :      formula::svSingleVectorRef)
      55             :      {
      56             :          const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
      57           0 :          formula::SingleVectorRefToken *>(vSubArguments[dataCol]->
      58           0 :          GetFormulaToken());
      59           0 :          ss << "    tmp"<<dataCol<<"=";
      60           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
      61           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
      62           0 :          ss << "tmp"<<dataCol<<"))\n";
      63           0 :          ss << "        tmp"<<dataCol<<"=0;\n";
      64             :      }
      65             :     else
      66           0 :         throw Unhandled();
      67           0 :     int conditionCol = 0;
      68           0 :     int conditionRow = 0;
      69           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
      70             :     formula::svDoubleVectorRef)
      71             :     {
      72           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]->
      73           0 :             GetFormulaToken();
      74             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
      75           0 :             formula::DoubleVectorRefToken *>(tmpCur);
      76           0 :         conditionCol = pCurDVR2->GetArrays().size();
      77           0 :         conditionRow = pCurDVR2->GetArrayLength();
      78             :     }
      79             :     else{
      80           0 :         throw Unhandled();
      81             :     }
      82           0 :     if(dataCol!=conditionCol)
      83           0 :             throw Unhandled();
      84           0 :     if(dataCol > 0 && dataRow > 0)
      85             :     {
      86           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
      87           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]->
      88           0 :             GetFormulaToken();
      89             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
      90           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
      91             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
      92           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
      93             : 
      94           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
      95           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
      96             :         {
      97           0 :             ss << "    int i,j,p;\n";
      98           0 :             ss << "    bool flag;\n";
      99           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
     100           0 :             ss << "    {\n";
     101           0 :             ss << "        i = p;\n";
     102           0 :             for(int i = 0; i < dataCol; ++i){
     103           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     104             :                         formula::svDoubleVectorRef)
     105           0 :                     throw Unhandled();
     106           0 :                 ss << "        tmp"<<i<<"=";
     107           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     108           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
     109           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
     110             :             }
     111           0 :             ss << "        flag = false;\n";
     112           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
     113           0 :             ss << "        {\n";
     114           0 :             ss << "            i = j;\n";
     115           0 :             ss << "            if (flag)\n";
     116           0 :             ss << "                break;\n";
     117           0 :             ss << "            else{\n";
     118           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
     119           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     120             :                         formula::svDoubleVectorRef)
     121           0 :                     throw Unhandled();
     122           0 :                 ss << "                tmp"<<i<<"=";
     123           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     124           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
     125           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
     126           0 :                 ss << i<<"){\n";
     127           0 :                 ss << "                        continue;\n";
     128           0 :                 ss << "                    }\n";
     129           0 :                 ss << "                }\n";
     130             :             }
     131           0 :             ss << "                flag=true;\n";
     132           0 :             ss << "            }\n";
     133           0 :             ss << "        }\n";
     134           0 :             ss << "        if (flag){\n";
     135           0 :             for(int i = 0; i < dataCol; ++i){
     136           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
     137           0 :                 ss << "                value=tmp"<<i<<";\n";
     138           0 :                 ss << "            }\n";
     139             :             }
     140           0 :             ss << "            if(max<value)\n";
     141           0 :             ss << "                max=value;";
     142           0 :             ss << "        }\n";
     143           0 :             ss << "    }\n";
     144             :         }
     145             :         else
     146           0 :             ss << "max = -1;\n";
     147             :     }
     148             :     else
     149           0 :         ss << "max = -1;\n";
     150           0 :     ss << "    return max;\n";
     151           0 :     ss << "}";
     152           0 : }
     153             : 
     154           0 : void OpDmin::GenSlidingWindowFunction(std::stringstream &ss,
     155             :             const std::string &sSymName, SubArguments &vSubArguments)
     156             : {
     157           0 :     ss << "\ndouble " << sSymName;
     158           0 :     ss << "_"<< BinFuncName() <<"(";
     159           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
     160             :     {
     161           0 :         if (i)
     162           0 :             ss << ",";
     163           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
     164             :     }
     165           0 :     ss << ")\n    {\n";
     166           0 :     ss << "    int gid0=get_global_id(0);\n";
     167           0 :     ss << "    double min = 1000000000000;\n";
     168           0 :     ss << "    double value=0.0;\n";
     169           0 :     GenTmpVariables(ss,vSubArguments);
     170           0 :     int dataCol = 0;
     171           0 :     int dataRow = 0;
     172           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
     173             :     formula::svDoubleVectorRef)
     174             :     {
     175           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     176             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     177           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     178           0 :         dataCol = pCurDVR1->GetArrays().size();
     179           0 :         dataRow = pCurDVR1->GetArrayLength();
     180             :     }
     181             :     else
     182           0 :         throw Unhandled();
     183           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
     184             :      formula::svSingleVectorRef)
     185             :      {
     186             :          const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
     187           0 :          formula::SingleVectorRefToken *>(vSubArguments[dataCol]->
     188           0 :          GetFormulaToken());
     189           0 :          ss << "    tmp"<<dataCol<<"=";
     190           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
     191           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
     192           0 :          ss << "tmp"<<dataCol<<"))\n";
     193           0 :          ss << "        tmp"<<dataCol<<"=0;\n";
     194             :      }
     195             :     else
     196           0 :         throw Unhandled();
     197           0 :     int conditionCol = 0;
     198           0 :     int conditionRow = 0;
     199           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
     200             :     formula::svDoubleVectorRef)
     201             :     {
     202           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]->
     203           0 :             GetFormulaToken();
     204             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     205           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     206           0 :         conditionCol = pCurDVR2->GetArrays().size();
     207           0 :         conditionRow = pCurDVR2->GetArrayLength();
     208             :     }
     209             :     else{
     210           0 :         throw Unhandled();
     211             :     }
     212           0 :     if(dataCol!=conditionCol)
     213           0 :             throw Unhandled();
     214           0 :     if(dataCol > 0 && dataRow > 0)
     215             :     {
     216           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
     217           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]->
     218           0 :             GetFormulaToken();
     219             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     220           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
     221             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     222           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
     223             : 
     224           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
     225           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
     226             :         {
     227           0 :             ss << "    int i,j,p;\n";
     228           0 :             ss << "    bool flag;\n";
     229             : 
     230           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
     231           0 :             ss << "    {\n";
     232           0 :             ss << "        i = p;\n";
     233           0 :             for(int i = 0; i < dataCol; ++i){
     234           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     235             :                         formula::svDoubleVectorRef)
     236           0 :                     throw Unhandled();
     237           0 :                 ss << "        tmp"<<i<<"=";
     238           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     239           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
     240           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
     241             :             }
     242           0 :             ss << "        flag = false;\n";
     243           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
     244           0 :             ss << "        {\n";
     245           0 :             ss << "            i = j;\n";
     246           0 :             ss << "            if (flag)\n";
     247           0 :             ss << "                break;\n";
     248           0 :             ss << "            else{\n";
     249           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
     250           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     251             :                         formula::svDoubleVectorRef)
     252           0 :                     throw Unhandled();
     253           0 :                 ss << "                tmp"<<i<<"=";
     254           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     255           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
     256           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
     257           0 :                 ss << i<<"){\n";
     258           0 :                 ss << "                        continue;\n";
     259           0 :                 ss << "                    }\n";
     260           0 :                 ss << "                }\n";
     261             :             }
     262           0 :             ss << "                flag=true;\n";
     263           0 :             ss << "            }\n";
     264           0 :             ss << "        }\n";
     265           0 :             ss << "        if (flag){\n";
     266           0 :             for(int i = 0; i < dataCol; ++i){
     267           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
     268           0 :                 ss << "                value=tmp"<<i<<";\n";
     269           0 :                 ss << "            }\n";
     270             :             }
     271           0 :             ss << "            if(min>value)\n";
     272           0 :             ss << "                min=value;";
     273           0 :             ss << "        }\n";
     274           0 :             ss << "    }\n";
     275             :         }
     276             :         else
     277           0 :             ss << "min = -1;\n";
     278             :     }
     279             :     else
     280           0 :         ss << "min = -1;\n";
     281           0 :     ss << "    return min;\n";
     282           0 :     ss << "}";
     283           0 : }
     284             : 
     285           0 : void OpDproduct::GenSlidingWindowFunction(std::stringstream &ss,
     286             :             const std::string &sSymName, SubArguments &vSubArguments)
     287             : {
     288           0 :     ss << "\ndouble " << sSymName;
     289           0 :     ss << "_"<< BinFuncName() <<"(";
     290           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
     291             :     {
     292           0 :         if (i)
     293           0 :             ss << ",";
     294           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
     295             :     }
     296           0 :     ss << ")\n    {\n";
     297           0 :     ss << "    int gid0=get_global_id(0);\n";
     298           0 :     ss << "    double product = 1;\n";
     299           0 :     ss << "    double value =0;\n";
     300           0 :     GenTmpVariables(ss,vSubArguments);
     301           0 :     int dataCol = 0;
     302           0 :     int dataRow = 0;
     303           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
     304             :     formula::svDoubleVectorRef)
     305             :     {
     306           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     307             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     308           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     309           0 :         dataCol = pCurDVR1->GetArrays().size();
     310           0 :         dataRow = pCurDVR1->GetArrayLength();
     311             :     }
     312             :     else
     313           0 :         throw Unhandled();
     314           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
     315             :      formula::svSingleVectorRef)
     316             :      {
     317             :          const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
     318           0 :          formula::SingleVectorRefToken *>(vSubArguments[dataCol]->
     319           0 :          GetFormulaToken());
     320           0 :          ss << "    tmp"<<dataCol<<"=";
     321           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
     322           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
     323           0 :          ss << "tmp"<<dataCol<<"))\n";
     324           0 :          ss << "        tmp"<<dataCol<<"=0;\n";
     325             :      }
     326             :     else
     327           0 :         throw Unhandled();
     328           0 :     int conditionCol = 0;
     329           0 :     int conditionRow = 0;
     330           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
     331             :     formula::svDoubleVectorRef)
     332             :     {
     333           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]->
     334           0 :             GetFormulaToken();
     335             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     336           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     337           0 :         conditionCol = pCurDVR2->GetArrays().size();
     338           0 :         conditionRow = pCurDVR2->GetArrayLength();
     339             :     }
     340             :     else{
     341           0 :         throw Unhandled();
     342             :     }
     343           0 :     if(dataCol!=conditionCol)
     344           0 :             throw Unhandled();
     345           0 :     if(dataCol > 0 && dataRow > 0)
     346             :     {
     347           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
     348           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]->
     349           0 :             GetFormulaToken();
     350             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     351           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
     352             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     353           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
     354             : 
     355           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
     356           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
     357             :         {
     358           0 :             ss << "    int i,j,p;\n";
     359           0 :             ss << "    bool flag;\n";
     360           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
     361           0 :             ss << "    {\n";
     362           0 :             ss << "        i = p;\n";
     363           0 :             for(int i = 0; i < dataCol; ++i){
     364           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     365             :                         formula::svDoubleVectorRef)
     366           0 :                     throw Unhandled();
     367           0 :                 ss << "        tmp"<<i<<"=";
     368           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     369           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
     370           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
     371             :             }
     372           0 :             ss << "        flag = false;\n";
     373           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
     374           0 :             ss << "        {\n";
     375           0 :             ss << "            i = j;\n";
     376           0 :             ss << "            if (flag)\n";
     377           0 :             ss << "                break;\n";
     378           0 :             ss << "            else{\n";
     379           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
     380           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     381             :                         formula::svDoubleVectorRef)
     382           0 :                     throw Unhandled();
     383           0 :                 ss << "                tmp"<<i<<"=";
     384           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     385           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
     386           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
     387           0 :                 ss << i<<"){\n";
     388           0 :                 ss << "                        continue;\n";
     389           0 :                 ss << "                    }\n";
     390           0 :                 ss << "                }\n";
     391             :             }
     392           0 :             ss << "                flag=true;\n";
     393           0 :             ss << "            }\n";
     394           0 :             ss << "        }\n";
     395           0 :             ss << "        if (flag){\n";
     396           0 :             for(int i = 0; i < dataCol; ++i){
     397           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
     398           0 :                 ss << "                value=tmp"<<i<<";\n";
     399           0 :                 ss << "            }\n";
     400             :             }
     401           0 :             ss << "            product*=value;\n";
     402           0 :             ss << "        }\n";
     403           0 :             ss << "    }\n";
     404             :         }
     405             :         else
     406           0 :             ss << "product = -1;\n";
     407             :     }
     408             :     else
     409           0 :         ss << "product = -1;\n";
     410           0 :     ss << "    return product;\n";
     411           0 :     ss << "}";
     412           0 : }
     413             : 
     414           0 : void OpDaverage::GenSlidingWindowFunction(std::stringstream &ss,
     415             :             const std::string &sSymName, SubArguments &vSubArguments)
     416             : {
     417           0 :     ss << "\ndouble " << sSymName;
     418           0 :     ss << "_"<< BinFuncName() <<"(";
     419           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
     420             :     {
     421           0 :         if (i)
     422           0 :             ss << ",";
     423           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
     424             :     }
     425           0 :     ss << ")\n    {\n";
     426           0 :     ss << "    int gid0=get_global_id(0);\n";
     427           0 :     ss << "    double sum = 0;\n";
     428           0 :     ss << "    int count = 0;\n";
     429           0 :     ss << "    double value =0;\n";
     430           0 :     GenTmpVariables(ss,vSubArguments);
     431           0 :     int dataCol = 0;
     432           0 :     int dataRow = 0;
     433           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
     434             :     formula::svDoubleVectorRef)
     435             :     {
     436           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     437             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     438           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     439           0 :         dataCol = pCurDVR1->GetArrays().size();
     440           0 :         dataRow = pCurDVR1->GetArrayLength();
     441             :     }
     442             :     else
     443           0 :         throw Unhandled();
     444           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
     445             :      formula::svSingleVectorRef)
     446             :      {
     447             :          const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
     448           0 :          formula::SingleVectorRefToken *>(vSubArguments[dataCol]->
     449           0 :          GetFormulaToken());
     450           0 :          ss << "    tmp"<<dataCol<<"=";
     451           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
     452           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
     453           0 :          ss << "tmp"<<dataCol<<"))\n";
     454           0 :          ss << "        tmp"<<dataCol<<"=0;\n";
     455             :      }
     456             :     else
     457           0 :         throw Unhandled();
     458           0 :     int conditionCol = 0;
     459           0 :     int conditionRow = 0;
     460           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
     461             :     formula::svDoubleVectorRef)
     462             :     {
     463           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]->
     464           0 :             GetFormulaToken();
     465             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     466           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     467           0 :         conditionCol = pCurDVR2->GetArrays().size();
     468           0 :         conditionRow = pCurDVR2->GetArrayLength();
     469             :     }
     470             :     else{
     471           0 :         throw Unhandled();
     472             :     }
     473           0 :     if(dataCol!=conditionCol)
     474           0 :             throw Unhandled();
     475           0 :     if(dataCol > 0 && dataRow > 0)
     476             :     {
     477           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
     478           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]->
     479           0 :             GetFormulaToken();
     480             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     481           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
     482             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     483           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
     484             : 
     485           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
     486           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
     487             :         {
     488           0 :             ss << "    int i,j,p;\n";
     489           0 :             ss << "    bool flag;\n";
     490             : 
     491           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
     492           0 :             ss << "    {\n";
     493           0 :             ss << "        i = p;\n";
     494           0 :             for(int i = 0; i < dataCol; ++i){
     495           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     496             :                         formula::svDoubleVectorRef)
     497           0 :                     throw Unhandled();
     498           0 :                 ss << "        tmp"<<i<<"=";
     499           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     500           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
     501           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
     502             :             }
     503           0 :             ss << "        flag = false;\n";
     504           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
     505           0 :             ss << "        {\n";
     506           0 :             ss << "            i = j;\n";
     507           0 :             ss << "            if (flag)\n";
     508           0 :             ss << "                break;\n";
     509           0 :             ss << "            else{\n";
     510           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
     511           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     512             :                         formula::svDoubleVectorRef)
     513           0 :                     throw Unhandled();
     514           0 :                 ss << "                tmp"<<i<<"=";
     515           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     516           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
     517           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
     518           0 :                 ss << i<<"){\n";
     519           0 :                 ss << "                        continue;\n";
     520           0 :                 ss << "                    }\n";
     521           0 :                 ss << "                }\n";
     522             :             }
     523           0 :             ss << "                flag=true;\n";
     524           0 :             ss << "            }\n";
     525           0 :             ss << "        }\n";
     526           0 :             ss << "        if (flag){\n";
     527           0 :             ss << "            count++;\n";
     528           0 :             for(int i = 0; i < dataCol; ++i){
     529           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
     530           0 :                 ss << "                value=tmp"<<i<<";\n";
     531           0 :                 ss << "            }\n";
     532             :             }
     533           0 :             ss << "            sum+=value;\n";
     534           0 :             ss << "        }\n";
     535           0 :             ss << "    }\n";
     536             :         }
     537             :         else
     538           0 :             ss << "sum = -1;\n";
     539             :     }
     540             :     else
     541           0 :         ss << "sum = -1;\n";
     542           0 :     ss << "    if(count==0)\n";
     543           0 :     ss << "        return 0;\n";
     544           0 :     ss << "    return sum/count;\n";
     545           0 :     ss << "}";
     546           0 : }
     547             : 
     548           0 : void OpDstdev::GenSlidingWindowFunction(std::stringstream &ss,
     549             :             const std::string &sSymName, SubArguments &vSubArguments)
     550             : {
     551           0 :     ss << "\ndouble " << sSymName;
     552           0 :     ss << "_"<< BinFuncName() <<"(";
     553           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
     554             :     {
     555           0 :         if (i)
     556           0 :             ss << ",";
     557           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
     558             :     }
     559           0 :     ss << ")\n    {\n";
     560           0 :     ss << "    int gid0=get_global_id(0);\n";
     561           0 :     ss << "    double var = 0;\n";
     562           0 :     ss << "    double mean = 0;\n";
     563           0 :     ss << "    double value =0;\n";
     564           0 :     ss << "    int count = 0;\n";
     565           0 :     GenTmpVariables(ss,vSubArguments);
     566           0 :     int dataCol = 0;
     567           0 :     int dataRow = 0;
     568           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
     569             :     formula::svDoubleVectorRef)
     570             :     {
     571           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     572             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     573           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     574           0 :         dataCol = pCurDVR1->GetArrays().size();
     575           0 :         dataRow = pCurDVR1->GetArrayLength();
     576             :     }
     577             :     else
     578           0 :         throw Unhandled();
     579           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
     580             :      formula::svSingleVectorRef)
     581             :      {
     582             :          const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
     583           0 :          formula::SingleVectorRefToken *>(vSubArguments[dataCol]->
     584           0 :          GetFormulaToken());
     585           0 :          ss << "    tmp"<<dataCol<<"=";
     586           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
     587           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
     588           0 :          ss << "tmp"<<dataCol<<"))\n";
     589           0 :          ss << "        tmp"<<dataCol<<"=0;\n";
     590             :      }
     591             :     else
     592           0 :         throw Unhandled();
     593           0 :     int conditionCol = 0;
     594           0 :     int conditionRow = 0;
     595           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
     596             :     formula::svDoubleVectorRef)
     597             :     {
     598           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]->
     599           0 :             GetFormulaToken();
     600             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     601           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     602           0 :         conditionCol = pCurDVR2->GetArrays().size();
     603           0 :         conditionRow = pCurDVR2->GetArrayLength();
     604             :     }
     605             :     else{
     606           0 :         throw Unhandled();
     607             :     }
     608           0 :     if(dataCol!=conditionCol)
     609           0 :             throw Unhandled();
     610           0 :     if(dataCol > 0 && dataRow > 0)
     611             :     {
     612           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
     613           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]->
     614           0 :             GetFormulaToken();
     615             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     616           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
     617             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     618           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
     619             : 
     620           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
     621           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
     622             :         {
     623           0 :             ss << "    int i,j,p;\n";
     624           0 :             ss << "    bool flag;\n";
     625             : 
     626           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
     627           0 :             ss << "    {\n";
     628           0 :             ss << "        i = p;\n";
     629           0 :             for(int i = 0; i < dataCol; ++i){
     630           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     631             :                         formula::svDoubleVectorRef)
     632           0 :                     throw Unhandled();
     633           0 :                 ss << "        tmp"<<i<<"=";
     634           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     635           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
     636           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
     637             :             }
     638           0 :             ss << "        flag = false;\n";
     639           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
     640           0 :             ss << "        {\n";
     641           0 :             ss << "            i = j;\n";
     642           0 :             ss << "            if (flag)\n";
     643           0 :             ss << "                break;\n";
     644           0 :             ss << "            else{\n";
     645           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
     646           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     647             :                         formula::svDoubleVectorRef)
     648           0 :                     throw Unhandled();
     649           0 :                 ss << "                tmp"<<i<<"=";
     650           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     651           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
     652           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
     653           0 :                 ss << i<<"){\n";
     654           0 :                 ss << "                        continue;\n";
     655           0 :                 ss << "                    }\n";
     656           0 :                 ss << "                }\n";
     657             :             }
     658           0 :             ss << "                flag=true;\n";
     659           0 :             ss << "            }\n";
     660           0 :             ss << "        }\n";
     661           0 :             ss << "        if (flag){\n";
     662           0 :             ss << "            count++;\n";
     663           0 :             for(int i = 0; i < dataCol; ++i){
     664           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
     665           0 :                 ss << "                value=tmp"<<i<<";\n";
     666           0 :                 ss << "            }\n";
     667             :             }
     668           0 :             ss << "            mean+=value;\n";
     669           0 :             ss << "        }\n";
     670           0 :             ss << "    }\n";
     671             : 
     672           0 :             ss << "    if(count<=1)\n";
     673           0 :             ss << "        return 0;\n";
     674             : 
     675           0 :             ss << "    mean/=count;\n";
     676             : 
     677           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
     678           0 :             ss << "    {\n";
     679           0 :             ss << "        i = p;\n";
     680           0 :             for(int i = 0; i < dataCol; ++i){
     681           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     682             :                         formula::svDoubleVectorRef)
     683           0 :                     throw Unhandled();
     684           0 :                 ss << "        tmp"<<i<<"=";
     685           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     686           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
     687           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
     688             :             }
     689           0 :             ss << "        flag = false;\n";
     690           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
     691           0 :             ss << "        {\n";
     692           0 :             ss << "            i = j;\n";
     693           0 :             ss << "            if (flag)\n";
     694           0 :             ss << "                break;\n";
     695           0 :             ss << "            else{\n";
     696           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
     697           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     698             :                         formula::svDoubleVectorRef)
     699           0 :                     throw Unhandled();
     700           0 :                 ss << "                tmp"<<i<<"=";
     701           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     702           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
     703           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
     704           0 :                 ss << i<<"){\n";
     705           0 :                 ss << "                        continue;\n";
     706           0 :                 ss << "                    }\n";
     707           0 :                 ss << "                }\n";
     708             :             }
     709           0 :             ss << "                flag=true;\n";
     710           0 :             ss << "            }\n";
     711           0 :             ss << "        }\n";
     712           0 :             ss << "        if (flag){\n";
     713           0 :             for(int i = 0; i < dataCol; ++i){
     714           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
     715           0 :                 ss << "                value=tmp"<<i<<";\n";
     716           0 :                 ss << "            }\n";
     717             :             }
     718           0 :             ss << "            var+=pow(mean-value,2);\n";
     719           0 :             ss << "        }\n";
     720           0 :             ss << "    }\n";
     721             : 
     722           0 :             ss << "    var = sqrt( var/(count-1) );\n";
     723             :         }
     724             :         else
     725           0 :             ss << "var = -1;\n";
     726             :     }
     727             :     else
     728           0 :         ss << "var = -1;\n";
     729           0 :     ss << "    return var;\n";
     730           0 :     ss << "}";
     731           0 : }
     732             : 
     733           0 : void OpDstdevp::GenSlidingWindowFunction(std::stringstream &ss,
     734             :             const std::string &sSymName, SubArguments &vSubArguments)
     735             : {
     736           0 :     ss << "\ndouble " << sSymName;
     737           0 :     ss << "_"<< BinFuncName() <<"(";
     738           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
     739             :     {
     740           0 :         if (i)
     741           0 :             ss << ",";
     742           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
     743             :     }
     744           0 :     ss << ")\n    {\n";
     745           0 :     ss << "    int gid0=get_global_id(0);\n";
     746           0 :     ss << "    double var = 0;\n";
     747           0 :     ss << "    double mean = 0;\n";
     748           0 :     ss << "    double value =0;\n";
     749           0 :     ss << "    int count = 0;\n";
     750           0 :     GenTmpVariables(ss,vSubArguments);
     751           0 :     int dataCol = 0;
     752           0 :     int dataRow = 0;
     753           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
     754             :     formula::svDoubleVectorRef)
     755             :     {
     756           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     757             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     758           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     759           0 :         dataCol = pCurDVR1->GetArrays().size();
     760           0 :         dataRow = pCurDVR1->GetArrayLength();
     761             :     }
     762             :     else
     763           0 :         throw Unhandled();
     764           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
     765             :      formula::svSingleVectorRef)
     766             :      {
     767             :          const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
     768           0 :          formula::SingleVectorRefToken *>(vSubArguments[dataCol]->
     769           0 :          GetFormulaToken());
     770           0 :          ss << "    tmp"<<dataCol<<"=";
     771           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
     772           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
     773           0 :          ss << "tmp"<<dataCol<<"))\n";
     774           0 :          ss << "        tmp"<<dataCol<<"=0;\n";
     775             :      }
     776             :     else
     777           0 :         throw Unhandled();
     778           0 :     int conditionCol = 0;
     779           0 :     int conditionRow = 0;
     780           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
     781             :     formula::svDoubleVectorRef)
     782             :     {
     783           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]->
     784           0 :             GetFormulaToken();
     785             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     786           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     787           0 :         conditionCol = pCurDVR2->GetArrays().size();
     788           0 :         conditionRow = pCurDVR2->GetArrayLength();
     789             :     }
     790             :     else{
     791           0 :         throw Unhandled();
     792             :     }
     793           0 :     if(dataCol!=conditionCol)
     794           0 :             throw Unhandled();
     795           0 :     if(dataCol > 0 && dataRow > 0)
     796             :     {
     797           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
     798           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]->
     799           0 :             GetFormulaToken();
     800             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     801           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
     802             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     803           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
     804             : 
     805           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
     806           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
     807             :         {
     808           0 :             ss << "    int i,j,p;\n";
     809           0 :             ss << "    bool flag;\n";
     810             : 
     811           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
     812           0 :             ss << "    {\n";
     813           0 :             ss << "        i = p;\n";
     814           0 :             for(int i = 0; i < dataCol; ++i){
     815           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     816             :                         formula::svDoubleVectorRef)
     817           0 :                     throw Unhandled();
     818           0 :                 ss << "        tmp"<<i<<"=";
     819           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     820           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
     821           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
     822             :             }
     823           0 :             ss << "        flag = false;\n";
     824           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
     825           0 :             ss << "        {\n";
     826           0 :             ss << "            i = j;\n";
     827           0 :             ss << "            if (flag)\n";
     828           0 :             ss << "                break;\n";
     829           0 :             ss << "            else{\n";
     830           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
     831           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     832             :                         formula::svDoubleVectorRef)
     833           0 :                     throw Unhandled();
     834           0 :                 ss << "                tmp"<<i<<"=";
     835           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     836           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
     837           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
     838           0 :                 ss << i<<"){\n";
     839           0 :                 ss << "                        continue;\n";
     840           0 :                 ss << "                    }\n";
     841           0 :                 ss << "                }\n";
     842             :             }
     843           0 :             ss << "                flag=true;\n";
     844           0 :             ss << "            }\n";
     845           0 :             ss << "        }\n";
     846           0 :             ss << "        if (flag){\n";
     847           0 :             ss << "            count++;\n";
     848           0 :             for(int i = 0; i < dataCol; ++i){
     849           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
     850           0 :                 ss << "                value=tmp"<<i<<";\n";
     851           0 :                 ss << "            }\n";
     852             :             }
     853           0 :             ss << "            mean+=value;\n";
     854           0 :             ss << "        }\n";
     855           0 :             ss << "    }\n";
     856             : 
     857           0 :             ss << "    if(count<=1)\n";
     858           0 :             ss << "        return 0;\n";
     859             : 
     860           0 :             ss << "    mean/=count;\n";
     861             : 
     862           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
     863           0 :             ss << "    {\n";
     864           0 :             ss << "        i = p;\n";
     865           0 :             for(int i = 0; i < dataCol; ++i){
     866           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     867             :                         formula::svDoubleVectorRef)
     868           0 :                     throw Unhandled();
     869           0 :                 ss << "        tmp"<<i<<"=";
     870           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     871           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
     872           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
     873             :             }
     874           0 :             ss << "        flag = false;\n";
     875           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
     876           0 :             ss << "        {\n";
     877           0 :             ss << "            i = j;\n";
     878           0 :             ss << "            if (flag)\n";
     879           0 :             ss << "                break;\n";
     880           0 :             ss << "            else{\n";
     881           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
     882           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     883             :                         formula::svDoubleVectorRef)
     884           0 :                     throw Unhandled();
     885           0 :                 ss << "                tmp"<<i<<"=";
     886           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
     887           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
     888           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
     889           0 :                 ss << i<<"){\n";
     890           0 :                 ss << "                        continue;\n";
     891           0 :                 ss << "                    }\n";
     892           0 :                 ss << "                }\n";
     893             :             }
     894           0 :             ss << "                flag=true;\n";
     895           0 :             ss << "            }\n";
     896           0 :             ss << "        }\n";
     897           0 :             ss << "        if (flag){\n";
     898           0 :             for(int i = 0; i < dataCol; ++i){
     899           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
     900           0 :                 ss << "                value=tmp"<<i<<";\n";
     901           0 :                 ss << "            }\n";
     902             :             }
     903           0 :             ss << "            var+=pow(mean-value,2);\n";
     904           0 :             ss << "        }\n";
     905           0 :             ss << "    }\n";
     906             : 
     907           0 :             ss << "    var = sqrt( var/count );\n";
     908             :         }
     909             :         else
     910           0 :             ss << "var = -1;\n";
     911             :     }
     912             :     else
     913           0 :         ss << "var = -1;\n";
     914           0 :     ss << "    return var;\n";
     915           0 :     ss << "}";
     916           0 : }
     917             : 
     918           0 : void OpDsum::GenSlidingWindowFunction(std::stringstream &ss,
     919             :             const std::string &sSymName, SubArguments &vSubArguments)
     920             : {
     921           0 :     ss << "\ndouble " << sSymName;
     922           0 :     ss << "_"<< BinFuncName() <<"(";
     923           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
     924             :     {
     925           0 :         if (i)
     926           0 :             ss << ",";
     927           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
     928             :     }
     929           0 :     ss << ")\n    {\n";
     930           0 :     ss << "    int gid0=get_global_id(0);\n";
     931           0 :     ss << "    double sum = 0;\n";
     932           0 :     ss << "    double value =0;\n";
     933           0 :     GenTmpVariables(ss,vSubArguments);
     934           0 :     int dataCol = 0;
     935           0 :     int dataRow = 0;
     936           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
     937             :     formula::svDoubleVectorRef)
     938             :     {
     939           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     940             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     941           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     942           0 :         dataCol = pCurDVR1->GetArrays().size();
     943           0 :         dataRow = pCurDVR1->GetArrayLength();
     944             :     }
     945             :     else
     946           0 :         throw Unhandled();
     947           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
     948             :      formula::svSingleVectorRef)
     949             :      {
     950             :          const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
     951           0 :          formula::SingleVectorRefToken *>(vSubArguments[dataCol]->
     952           0 :          GetFormulaToken());
     953           0 :          ss << "    tmp"<<dataCol<<"=";
     954           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
     955           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
     956           0 :          ss << "tmp"<<dataCol<<"))\n";
     957           0 :          ss << "        tmp"<<dataCol<<"=0;\n";
     958             :      }
     959             :     else
     960           0 :         throw Unhandled();
     961           0 :     int conditionCol = 0;
     962           0 :     int conditionRow = 0;
     963           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
     964             :     formula::svDoubleVectorRef)
     965             :     {
     966           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]->
     967           0 :             GetFormulaToken();
     968             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     969           0 :             formula::DoubleVectorRefToken *>(tmpCur);
     970           0 :         conditionCol = pCurDVR2->GetArrays().size();
     971           0 :         conditionRow = pCurDVR2->GetArrayLength();
     972             :     }
     973             :     else{
     974           0 :         throw Unhandled();
     975             :     }
     976           0 :     if(dataCol!=conditionCol)
     977           0 :             throw Unhandled();
     978           0 :     if(dataCol > 0 && dataRow > 0)
     979             :     {
     980           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
     981           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]->
     982           0 :             GetFormulaToken();
     983             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
     984           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
     985             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
     986           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
     987             : 
     988           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
     989           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
     990             :         {
     991           0 :             ss << "    int i,j,p;\n";
     992           0 :             ss << "    bool flag;\n";
     993             : 
     994           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
     995           0 :             ss << "    {\n";
     996           0 :             ss << "        i = p;\n";
     997           0 :             for(int i = 0; i < dataCol; ++i){
     998           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
     999             :                         formula::svDoubleVectorRef)
    1000           0 :                     throw Unhandled();
    1001           0 :                 ss << "        tmp"<<i<<"=";
    1002           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1003           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
    1004           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
    1005             :             }
    1006           0 :             ss << "        flag = false;\n";
    1007           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
    1008           0 :             ss << "        {\n";
    1009           0 :             ss << "            i = j;\n";
    1010           0 :             ss << "            if (flag)\n";
    1011           0 :             ss << "                break;\n";
    1012           0 :             ss << "            else{\n";
    1013           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
    1014           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1015             :                         formula::svDoubleVectorRef)
    1016           0 :                     throw Unhandled();
    1017           0 :                 ss << "                tmp"<<i<<"=";
    1018           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1019           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
    1020           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
    1021           0 :                 ss << i<<"){\n";
    1022           0 :                 ss << "                        continue;\n";
    1023           0 :                 ss << "                    }\n";
    1024           0 :                 ss << "                }\n";
    1025             :             }
    1026           0 :             ss << "                flag=true;\n";
    1027           0 :             ss << "            }\n";
    1028           0 :             ss << "        }\n";
    1029           0 :             ss << "        if (flag){\n";
    1030           0 :             for(int i = 0; i < dataCol; ++i){
    1031           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
    1032           0 :                 ss << "                value=tmp"<<i<<";\n";
    1033           0 :                 ss << "            }\n";
    1034             :             }
    1035           0 :             ss << "            sum+=value;\n";
    1036           0 :             ss << "        }\n";
    1037           0 :             ss << "    }\n";
    1038             :         }
    1039             :         else
    1040           0 :             ss << "sum = -1;\n";
    1041             :     }
    1042             :     else
    1043           0 :         ss << "sum = -1;\n";
    1044           0 :     ss << "    return sum;\n";
    1045           0 :     ss << "}";
    1046           0 : }
    1047             : 
    1048           0 : void OpDvar::GenSlidingWindowFunction(std::stringstream &ss,
    1049             :             const std::string &sSymName, SubArguments &vSubArguments)
    1050             : {
    1051           0 :     ss << "\ndouble " << sSymName;
    1052           0 :     ss << "_"<< BinFuncName() <<"(";
    1053           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
    1054             :     {
    1055           0 :         if (i)
    1056           0 :             ss << ",";
    1057           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
    1058             :     }
    1059           0 :     ss << ")\n    {\n";
    1060           0 :     ss << "    int gid0=get_global_id(0);\n";
    1061           0 :     ss << "    double var = 0;\n";
    1062           0 :     ss << "    double mean = 0;\n";
    1063           0 :     ss << "    double value =0;\n";
    1064           0 :     ss << "    int count = 0;\n";
    1065           0 :     GenTmpVariables(ss,vSubArguments);
    1066           0 :     int dataCol = 0;
    1067           0 :     int dataRow = 0;
    1068           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
    1069             :     formula::svDoubleVectorRef)
    1070             :     {
    1071           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
    1072             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
    1073           0 :             formula::DoubleVectorRefToken *>(tmpCur);
    1074           0 :         dataCol = pCurDVR1->GetArrays().size();
    1075           0 :         dataRow = pCurDVR1->GetArrayLength();
    1076             :     }
    1077             :     else
    1078           0 :         throw Unhandled();
    1079           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
    1080             :      formula::svSingleVectorRef)
    1081             :      {
    1082             :          const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
    1083           0 :          formula::SingleVectorRefToken *>(vSubArguments[dataCol]->
    1084           0 :          GetFormulaToken());
    1085           0 :          ss << "    tmp"<<dataCol<<"=";
    1086           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
    1087           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
    1088           0 :          ss << "tmp"<<dataCol<<"))\n";
    1089           0 :          ss << "        tmp"<<dataCol<<"=0;\n";
    1090             :      }
    1091             :     else
    1092           0 :         throw Unhandled();
    1093           0 :     int conditionCol = 0;
    1094           0 :     int conditionRow = 0;
    1095           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
    1096             :     formula::svDoubleVectorRef)
    1097             :     {
    1098           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]->
    1099           0 :             GetFormulaToken();
    1100             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
    1101           0 :             formula::DoubleVectorRefToken *>(tmpCur);
    1102           0 :         conditionCol = pCurDVR2->GetArrays().size();
    1103           0 :         conditionRow = pCurDVR2->GetArrayLength();
    1104             :     }
    1105             :     else{
    1106           0 :         throw Unhandled();
    1107             :     }
    1108           0 :     if(dataCol!=conditionCol)
    1109           0 :             throw Unhandled();
    1110           0 :     if(dataCol > 0 && dataRow > 0)
    1111             :     {
    1112           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
    1113           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]->
    1114           0 :             GetFormulaToken();
    1115             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
    1116           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
    1117             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
    1118           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
    1119             : 
    1120           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
    1121           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
    1122             :         {
    1123           0 :             ss << "    int i,j,p;\n";
    1124           0 :             ss << "    bool flag;\n";
    1125             : 
    1126           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
    1127           0 :             ss << "    {\n";
    1128           0 :             ss << "        i = p;\n";
    1129           0 :             for(int i = 0; i < dataCol; ++i){
    1130           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1131             :                         formula::svDoubleVectorRef)
    1132           0 :                     throw Unhandled();
    1133           0 :                 ss << "        tmp"<<i<<"=";
    1134           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1135           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
    1136           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
    1137             :             }
    1138           0 :             ss << "        flag = false;\n";
    1139           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
    1140           0 :             ss << "        {\n";
    1141           0 :             ss << "            i = j;\n";
    1142           0 :             ss << "            if (flag)\n";
    1143           0 :             ss << "                break;\n";
    1144           0 :             ss << "            else{\n";
    1145           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
    1146           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1147             :                         formula::svDoubleVectorRef)
    1148           0 :                     throw Unhandled();
    1149           0 :                 ss << "                tmp"<<i<<"=";
    1150           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1151           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
    1152           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
    1153           0 :                 ss << i<<"){\n";
    1154           0 :                 ss << "                        continue;\n";
    1155           0 :                 ss << "                    }\n";
    1156           0 :                 ss << "                }\n";
    1157             :             }
    1158           0 :             ss << "                flag=true;\n";
    1159           0 :             ss << "            }\n";
    1160           0 :             ss << "        }\n";
    1161           0 :             ss << "        if (flag){\n";
    1162           0 :             ss << "            count++;\n";
    1163           0 :             for(int i = 0; i < dataCol; ++i){
    1164           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
    1165           0 :                 ss << "                value=tmp"<<i<<";\n";
    1166           0 :                 ss << "            }\n";
    1167             :             }
    1168           0 :             ss << "            mean+=value;\n";
    1169           0 :             ss << "        }\n";
    1170           0 :             ss << "    }\n";
    1171             : 
    1172           0 :             ss << "    if(count<=1)\n";
    1173           0 :             ss << "        return 0;\n";
    1174             : 
    1175           0 :             ss << "    mean/=count;\n";
    1176             : 
    1177           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
    1178           0 :             ss << "    {\n";
    1179           0 :             ss << "        i = p;\n";
    1180           0 :             for(int i = 0; i < dataCol; ++i){
    1181           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1182             :                         formula::svDoubleVectorRef)
    1183           0 :                     throw Unhandled();
    1184           0 :                 ss << "        tmp"<<i<<"=";
    1185           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1186           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
    1187           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
    1188             :             }
    1189           0 :             ss << "        flag = false;\n";
    1190           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
    1191           0 :             ss << "        {\n";
    1192           0 :             ss << "            i = j;\n";
    1193           0 :             ss << "            if (flag)\n";
    1194           0 :             ss << "                break;\n";
    1195           0 :             ss << "            else{\n";
    1196           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
    1197           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1198             :                         formula::svDoubleVectorRef)
    1199           0 :                     throw Unhandled();
    1200           0 :                 ss << "                tmp"<<i<<"=";
    1201           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1202           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
    1203           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
    1204           0 :                 ss << i<<"){\n";
    1205           0 :                 ss << "                        continue;\n";
    1206           0 :                 ss << "                    }\n";
    1207           0 :                 ss << "                }\n";
    1208             :             }
    1209           0 :             ss << "                flag=true;\n";
    1210           0 :             ss << "            }\n";
    1211           0 :             ss << "        }\n";
    1212           0 :             ss << "        if (flag){\n";
    1213           0 :             for(int i = 0; i < dataCol; ++i){
    1214           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
    1215           0 :                 ss << "                value=tmp"<<i<<";\n";
    1216           0 :                 ss << "            }\n";
    1217             :             }
    1218           0 :             ss << "            var+=pow(mean-value,2);\n";
    1219           0 :             ss << "        }\n";
    1220           0 :             ss << "    }\n";
    1221             : 
    1222           0 :             ss << "    var = var/(count-1);\n";
    1223             :         }
    1224             :         else
    1225           0 :             ss << "var = -1;\n";
    1226             :     }
    1227             :     else
    1228           0 :         ss << "var = -1;\n";
    1229           0 :     ss << "    return var;\n";
    1230           0 :     ss << "}";
    1231           0 : }
    1232             : 
    1233           0 : void OpDvarp::GenSlidingWindowFunction(std::stringstream &ss,
    1234             :             const std::string &sSymName, SubArguments &vSubArguments)
    1235             : {
    1236           0 :     ss << "\ndouble " << sSymName;
    1237           0 :     ss << "_"<< BinFuncName() <<"(";
    1238           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
    1239             :     {
    1240           0 :         if (i)
    1241           0 :             ss << ",";
    1242           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
    1243             :     }
    1244           0 :     ss << ")\n    {\n";
    1245           0 :     ss << "    int gid0=get_global_id(0);\n";
    1246           0 :     ss << "    double var = 0;\n";
    1247           0 :     ss << "    double mean = 0;\n";
    1248           0 :     ss << "    double value =0;\n";
    1249           0 :     ss << "    int count = 0;\n";
    1250           0 :     GenTmpVariables(ss,vSubArguments);
    1251           0 :     int dataCol = 0;
    1252           0 :     int dataRow = 0;
    1253           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
    1254             :     formula::svDoubleVectorRef)
    1255             :     {
    1256           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
    1257             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
    1258           0 :             formula::DoubleVectorRefToken *>(tmpCur);
    1259           0 :         dataCol = pCurDVR1->GetArrays().size();
    1260           0 :         dataRow = pCurDVR1->GetArrayLength();
    1261             :     }
    1262             :     else
    1263           0 :         throw Unhandled();
    1264           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
    1265             :      formula::svSingleVectorRef)
    1266             :      {
    1267             :          const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
    1268           0 :          formula::SingleVectorRefToken *>(vSubArguments[dataCol]->
    1269           0 :          GetFormulaToken());
    1270           0 :          ss << "    tmp"<<dataCol<<"=";
    1271           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
    1272           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
    1273           0 :          ss << "tmp"<<dataCol<<"))\n";
    1274           0 :          ss << "        tmp"<<dataCol<<"=0;\n";
    1275             :      }
    1276             :     else
    1277           0 :         throw Unhandled();
    1278           0 :     int conditionCol = 0;
    1279           0 :     int conditionRow = 0;
    1280           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
    1281             :     formula::svDoubleVectorRef)
    1282             :     {
    1283           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]->
    1284           0 :             GetFormulaToken();
    1285             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
    1286           0 :             formula::DoubleVectorRefToken *>(tmpCur);
    1287           0 :         conditionCol = pCurDVR2->GetArrays().size();
    1288           0 :         conditionRow = pCurDVR2->GetArrayLength();
    1289             :     }
    1290             :     else{
    1291           0 :         throw Unhandled();
    1292             :     }
    1293           0 :     if(dataCol!=conditionCol)
    1294           0 :             throw Unhandled();
    1295           0 :     if(dataCol > 0 && dataRow > 0)
    1296             :     {
    1297           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
    1298           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]->
    1299           0 :             GetFormulaToken();
    1300             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
    1301           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
    1302             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
    1303           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
    1304             : 
    1305           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
    1306           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
    1307             :         {
    1308           0 :             ss << "    int i,j,p;\n";
    1309           0 :             ss << "    bool flag;\n";
    1310             : 
    1311           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
    1312           0 :             ss << "    {\n";
    1313           0 :             ss << "        i = p;\n";
    1314           0 :             for(int i = 0; i < dataCol; ++i){
    1315           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1316             :                         formula::svDoubleVectorRef)
    1317           0 :                     throw Unhandled();
    1318           0 :                 ss << "        tmp"<<i<<"=";
    1319           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1320           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
    1321           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
    1322             :             }
    1323           0 :             ss << "        flag = false;\n";
    1324           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
    1325           0 :             ss << "        {\n";
    1326           0 :             ss << "            i = j;\n";
    1327           0 :             ss << "            if (flag)\n";
    1328           0 :             ss << "                break;\n";
    1329           0 :             ss << "            else{\n";
    1330           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
    1331           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1332             :                         formula::svDoubleVectorRef)
    1333           0 :                     throw Unhandled();
    1334           0 :                 ss << "                tmp"<<i<<"=";
    1335           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1336           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
    1337           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
    1338           0 :                 ss << i<<"){\n";
    1339           0 :                 ss << "                        continue;\n";
    1340           0 :                 ss << "                    }\n";
    1341           0 :                 ss << "                }\n";
    1342             :             }
    1343           0 :             ss << "                flag=true;\n";
    1344           0 :             ss << "            }\n";
    1345           0 :             ss << "        }\n";
    1346           0 :             ss << "        if (flag){\n";
    1347           0 :             ss << "            count++;\n";
    1348           0 :             for(int i = 0; i < dataCol; ++i){
    1349           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
    1350           0 :                 ss << "                value=tmp"<<i<<";\n";
    1351           0 :                 ss << "            }\n";
    1352             :             }
    1353           0 :             ss << "            mean+=value;\n";
    1354           0 :             ss << "        }\n";
    1355           0 :             ss << "    }\n";
    1356             : 
    1357           0 :             ss << "    if(count<=0)\n";
    1358           0 :             ss << "        return 0;\n";
    1359             : 
    1360           0 :             ss << "    mean/=count;\n";
    1361             : 
    1362           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
    1363           0 :             ss << "    {\n";
    1364           0 :             ss << "        i = p;\n";
    1365           0 :             for(int i = 0; i < dataCol; ++i){
    1366           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1367             :                         formula::svDoubleVectorRef)
    1368           0 :                     throw Unhandled();
    1369           0 :                 ss << "        tmp"<<i<<"=";
    1370           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1371           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
    1372           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
    1373             :             }
    1374           0 :             ss << "        flag = false;\n";
    1375           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
    1376           0 :             ss << "        {\n";
    1377           0 :             ss << "            i = j;\n";
    1378           0 :             ss << "            if (flag)\n";
    1379           0 :             ss << "                break;\n";
    1380           0 :             ss << "            else{\n";
    1381           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
    1382           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1383             :                         formula::svDoubleVectorRef)
    1384           0 :                     throw Unhandled();
    1385           0 :                 ss << "                tmp"<<i<<"=";
    1386           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1387           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
    1388           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
    1389           0 :                 ss << i<<"){\n";
    1390           0 :                 ss << "                        continue;\n";
    1391           0 :                 ss << "                    }\n";
    1392           0 :                 ss << "                }\n";
    1393             :             }
    1394           0 :             ss << "                flag=true;\n";
    1395           0 :             ss << "            }\n";
    1396           0 :             ss << "        }\n";
    1397           0 :             ss << "        if (flag){\n";
    1398           0 :             for(int i = 0; i < dataCol; ++i){
    1399           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
    1400           0 :                 ss << "                value=tmp"<<i<<";\n";
    1401           0 :                 ss << "            }\n";
    1402             :             }
    1403           0 :             ss << "            var+=pow(mean-value,2);\n";
    1404           0 :             ss << "        }\n";
    1405           0 :             ss << "    }\n";
    1406             : 
    1407           0 :             ss << "    var = var/count;\n";
    1408             :         }
    1409             :         else
    1410           0 :             ss << "var = -1;\n";
    1411             :     }
    1412             :     else
    1413           0 :         ss << "var = -1;\n";
    1414           0 :     ss << "    return var;\n";
    1415           0 :     ss << "}";
    1416           0 : }
    1417             : 
    1418           0 : void OpDcount::GenSlidingWindowFunction(std::stringstream &ss,
    1419             :             const std::string &sSymName, SubArguments &vSubArguments)
    1420             : {
    1421           0 :     ss << "\ndouble " << sSymName;
    1422           0 :     ss << "_"<< BinFuncName() <<"(";
    1423           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
    1424             :     {
    1425           0 :         if (i)
    1426           0 :             ss << ",";
    1427           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
    1428             :     }
    1429           0 :     ss << ")\n    {\n";
    1430           0 :     ss << "    int gid0=get_global_id(0);\n";
    1431           0 :     ss << "    double value=0;\n";
    1432           0 :     ss << "    int count = 0;\n";
    1433           0 :     GenTmpVariables(ss,vSubArguments);
    1434           0 :     int dataCol = 0;
    1435           0 :     int dataRow = 0;
    1436           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
    1437             :     formula::svDoubleVectorRef)
    1438             :     {
    1439           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
    1440             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
    1441           0 :             formula::DoubleVectorRefToken *>(tmpCur);
    1442           0 :         dataCol = pCurDVR1->GetArrays().size();
    1443           0 :         dataRow = pCurDVR1->GetArrayLength();
    1444             :     }
    1445             :     else
    1446           0 :         throw Unhandled();
    1447           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
    1448             :      formula::svSingleVectorRef)
    1449             :      {
    1450             :         const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
    1451           0 :             formula::SingleVectorRefToken *>(vSubArguments[dataCol]
    1452           0 :             ->GetFormulaToken());
    1453           0 :          ss << "    tmp"<<dataCol<<"=";
    1454           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
    1455           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
    1456           0 :          ss << "tmp"<<dataCol<<"))\n";
    1457           0 :          ss << "        tmp"<<dataCol<<"=DBL_MIN;\n";
    1458             :      }
    1459             :     else
    1460           0 :         throw Unhandled();
    1461           0 :     int conditionCol = 0;
    1462           0 :     int conditionRow = 0;
    1463           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
    1464             :     formula::svDoubleVectorRef)
    1465             :     {
    1466           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]
    1467           0 :             ->GetFormulaToken();
    1468             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
    1469           0 :             formula::DoubleVectorRefToken *>(tmpCur);
    1470           0 :         conditionCol = pCurDVR2->GetArrays().size();
    1471           0 :         conditionRow = pCurDVR2->GetArrayLength();
    1472             :     }
    1473             :     else{
    1474           0 :         throw Unhandled();
    1475             :     }
    1476           0 :     if(dataCol!=conditionCol)
    1477           0 :             throw Unhandled();
    1478           0 :     if(dataCol > 0 && dataRow > 0)
    1479             :     {
    1480           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
    1481           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]
    1482           0 :             ->GetFormulaToken();
    1483             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
    1484           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
    1485             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
    1486           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
    1487             : 
    1488           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
    1489           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
    1490             :         {
    1491           0 :             ss << "    int i,j,p;\n";
    1492           0 :             ss << "    bool flag;\n";
    1493             : 
    1494           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
    1495           0 :             ss << "    {\n";
    1496           0 :             ss << "        i = p;\n";
    1497           0 :             for(int i = 0; i < dataCol; ++i){
    1498           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1499             :                         formula::svDoubleVectorRef)
    1500           0 :                     throw Unhandled();
    1501           0 :                 ss << "        tmp"<<i<<"=";
    1502           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1503           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
    1504           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
    1505             :             }
    1506           0 :             ss << "        flag = false;\n";
    1507           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
    1508           0 :             ss << "        {\n";
    1509           0 :             ss << "            i = j;\n";
    1510           0 :             ss << "            if (flag)\n";
    1511           0 :             ss << "                break;\n";
    1512           0 :             ss << "            else{\n";
    1513           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
    1514           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1515             :                         formula::svDoubleVectorRef)
    1516           0 :                     throw Unhandled();
    1517           0 :                 ss << "                tmp"<<i<<"=";
    1518           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1519           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
    1520           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
    1521           0 :                 ss << i<<"){\n";
    1522           0 :                 ss << "                        continue;\n";
    1523           0 :                 ss << "                    }\n";
    1524           0 :                 ss << "                }\n";
    1525             :             }
    1526           0 :             ss << "                flag=true;\n";
    1527           0 :             ss << "            }\n";
    1528           0 :             ss << "        }\n";
    1529           0 :             ss << "        if (flag){\n";
    1530           0 :             for(int i = 0; i < dataCol; ++i){
    1531           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
    1532           0 :                 ss << "                value=tmp"<<i<<";\n";
    1533           0 :                 ss << "            }\n";
    1534             :             }
    1535           0 :             ss << "            if(value > DBL_MIN)\n";
    1536           0 :             ss << "                count++;\n";
    1537           0 :             ss << "        }\n";
    1538           0 :             ss << "     }\n";
    1539             :         }
    1540             :         else
    1541           0 :             ss << "count = -1;\n";
    1542             :     }
    1543             :     else
    1544           0 :         ss << "count = -1;\n";
    1545           0 :     ss << "    return count;\n";
    1546           0 :     ss << "}";
    1547           0 : }
    1548             : 
    1549           0 : void OpDcount2::GenSlidingWindowFunction(std::stringstream &ss,
    1550             :             const std::string &sSymName, SubArguments &vSubArguments)
    1551             : {
    1552           0 :     ss << "\ndouble " << sSymName;
    1553           0 :     ss << "_"<< BinFuncName() <<"(";
    1554           0 :     for (unsigned i = 0; i < vSubArguments.size(); i++)
    1555             :     {
    1556           0 :         if (i)
    1557           0 :             ss << ",";
    1558           0 :         vSubArguments[i]->GenSlidingWindowDecl(ss);
    1559             :     }
    1560           0 :     ss << ")\n    {\n";
    1561           0 :     ss << "    int gid0=get_global_id(0);\n";
    1562           0 :     ss << "    double value=0;\n";
    1563           0 :     ss << "    int count = 0;\n";
    1564           0 :     GenTmpVariables(ss,vSubArguments);
    1565           0 :     int dataCol = 0;
    1566           0 :     int dataRow = 0;
    1567           0 :     if(vSubArguments[0]->GetFormulaToken()->GetType() ==
    1568             :     formula::svDoubleVectorRef)
    1569             :     {
    1570           0 :         formula::FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
    1571             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
    1572           0 :             formula::DoubleVectorRefToken *>(tmpCur);
    1573           0 :         dataCol = pCurDVR1->GetArrays().size();
    1574           0 :         dataRow = pCurDVR1->GetArrayLength();
    1575             :     }
    1576             :     else
    1577           0 :         throw Unhandled();
    1578           0 :     if(vSubArguments[dataCol]->GetFormulaToken()->GetType() ==
    1579             :      formula::svSingleVectorRef)
    1580             :      {
    1581             :         const formula::SingleVectorRefToken*pTmpDVR1= static_cast<const
    1582           0 :             formula::SingleVectorRefToken *>(vSubArguments[dataCol]
    1583           0 :             ->GetFormulaToken());
    1584           0 :          ss << "    tmp"<<dataCol<<"=";
    1585           0 :          ss << vSubArguments[dataCol]->GenSlidingWindowDeclRef()<<";\n";
    1586           0 :          ss << "    if(gid0>="<<pTmpDVR1->GetArrayLength()<<" ||isNan(";
    1587           0 :          ss << "tmp"<<dataCol<<"))\n";
    1588           0 :          ss << "        tmp"<<dataCol<<"=DBL_MIN;\n";
    1589             :      }
    1590             :     else
    1591           0 :         throw Unhandled();
    1592           0 :     int conditionCol = 0;
    1593           0 :     int conditionRow = 0;
    1594           0 :     if(vSubArguments[dataCol + 1]->GetFormulaToken()->GetType() ==
    1595             :     formula::svDoubleVectorRef)
    1596             :     {
    1597           0 :         formula::FormulaToken *tmpCur = vSubArguments[dataCol + 1]->
    1598           0 :             GetFormulaToken();
    1599             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
    1600           0 :             formula::DoubleVectorRefToken *>(tmpCur);
    1601           0 :         conditionCol = pCurDVR2->GetArrays().size();
    1602           0 :         conditionRow = pCurDVR2->GetArrayLength();
    1603             :     }
    1604             :     else{
    1605           0 :         throw Unhandled();
    1606             :     }
    1607           0 :     if(dataCol!=conditionCol)
    1608           0 :             throw Unhandled();
    1609           0 :     if(dataCol > 0 && dataRow > 0)
    1610             :     {
    1611           0 :         formula::FormulaToken *tmpCur1 = vSubArguments[0]->GetFormulaToken();
    1612           0 :         formula::FormulaToken *tmpCur2 = vSubArguments[dataCol + 1]->
    1613           0 :             GetFormulaToken();
    1614             :         const formula::DoubleVectorRefToken*pCurDVR1= static_cast<const
    1615           0 :             formula::DoubleVectorRefToken *>(tmpCur1);
    1616             :         const formula::DoubleVectorRefToken*pCurDVR2= static_cast<const
    1617           0 :             formula::DoubleVectorRefToken *>(tmpCur2);
    1618             : 
    1619           0 :         if(pCurDVR1->IsStartFixed() && pCurDVR1->IsEndFixed() &&
    1620           0 :             pCurDVR2->IsStartFixed() && pCurDVR2->IsEndFixed())
    1621             :         {
    1622           0 :             ss << "    int i,j,p;\n";
    1623           0 :             ss << "    bool flag;\n";
    1624             : 
    1625           0 :             ss << "    for(p = 1;p < " << dataRow << ";++p)\n";
    1626           0 :             ss << "    {\n";
    1627           0 :             ss << "        i = p;\n";
    1628           0 :             for(int i = 0; i < dataCol; ++i){
    1629           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1630             :                         formula::svDoubleVectorRef)
    1631           0 :                     throw Unhandled();
    1632           0 :                 ss << "        tmp"<<i<<"=";
    1633           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1634           0 :                 ss << "        if(isNan(tmp"<<i<<"))\n";
    1635           0 :                 ss <<"            tmp"<<i<<" = 0;\n";
    1636             :             }
    1637           0 :             ss << "        flag = false;\n";
    1638           0 :             ss << "        for(j = 1; j < " << conditionRow << ";++j)\n";
    1639           0 :             ss << "        {\n";
    1640           0 :             ss << "            i = j;\n";
    1641           0 :             ss << "            if (flag)\n";
    1642           0 :             ss << "                break;\n";
    1643           0 :             ss << "            else{\n";
    1644           0 :             for(int i = dataCol + 1; i < dataCol + 1 + conditionCol; ++i){
    1645           0 :                 if(vSubArguments[i]->GetFormulaToken()->GetType() !=
    1646             :                         formula::svDoubleVectorRef)
    1647           0 :                     throw Unhandled();
    1648           0 :                 ss << "                tmp"<<i<<"=";
    1649           0 :                 ss << vSubArguments[i]->GenSlidingWindowDeclRef()<<";\n";
    1650           0 :                 ss << "                if(!isNan(tmp"<<i<<")){\n";
    1651           0 :                 ss << "                    if(tmp"<<(i-dataCol-1)<<"!=tmp";
    1652           0 :                 ss << i<<"){\n";
    1653           0 :                 ss << "                        continue;\n";
    1654           0 :                 ss << "                    }\n";
    1655           0 :                 ss << "                }\n";
    1656             :             }
    1657           0 :             ss << "                flag=true;\n";
    1658           0 :             ss << "            }\n";
    1659           0 :             ss << "        }\n";
    1660           0 :             ss << "        if (flag){\n";
    1661           0 :             for(int i = 0; i < dataCol; ++i){
    1662           0 :                 ss << "            if(tmp"<<dataCol<<"=="<<(i+1)<<"){\n";
    1663           0 :                 ss << "                value=tmp"<<i<<";\n";
    1664           0 :                 ss << "            }\n";
    1665             :             }
    1666           0 :             ss << "            if(value > DBL_MIN)\n";
    1667           0 :             ss << "                count++;\n";
    1668           0 :             ss << "        }\n";
    1669           0 :             ss << "     }\n";
    1670             :         }
    1671             :         else
    1672           0 :             ss << "count = -1;\n";
    1673             :     }
    1674             :     else
    1675           0 :         ss << "count = -1;\n";
    1676           0 :     ss << "    return count;\n";
    1677           0 :     ss << "}";
    1678           0 : }
    1679             : 
    1680             : }}
    1681             : 
    1682             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10