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

Generated by: LCOV version 1.10