Properly split header and source files.

Without this, formulagroupcl.cxx alone would take minutes to compile.

Change-Id: I7d55ed22fbd7f5c0859d5f1bf2a4e4eafd47ac3b

sc/Library_scopencl.mk

@@ -38,6 +38,10 @@ $(eval $(call gb_Library_use_libraries,scopencl,\
 $(eval $(call gb_Library_add_exception_objects,scopencl,\
         sc/source/core/opencl/formulagroupcl \
         sc/source/core/opencl/openclwrapper \
+        sc/source/core/opencl/op_financial \
+        sc/source/core/opencl/op_database \
+        sc/source/core/opencl/op_math \
+        sc/source/core/opencl/op_statistical \
         sc/source/core/opencl/clcc/clew \
 ))
 

sc/source/core/opencl/formulagroupcl.cxx

@@ -18,10 +18,10 @@
 
 #include "openclwrapper.hxx"
 
-#include "op_financial.cxx"
-#include "op_database.cxx"
-#include "op_math.cxx"
-#include "op_statistical.cxx"
+#include "op_financial.hxx"
+#include "op_database.hxx"
+#include "op_math.hxx"
+#include "op_statistical.hxx"
 #include "formulagroupcl_public.hxx"
 #include "formulagroupcl_finacial.hxx"
 

sc/source/core/opencl/op_database.cxx

@@ -7,26 +7,12 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-#ifndef OP_DATABASE
-#define OP_DATABASE
-#include "formulagroup.hxx"
-#include "document.hxx"
-#include "formulacell.hxx"
-#include "tokenarray.hxx"
-#include "compiler.hxx"
-#include "interpre.hxx"
-#include "opbase.hxx"
-#include<list>
-#include <iostream>
-#include <sstream>
-#include <algorithm>
-
-#include <memory>
-using namespace formula;
+#include "op_database.hxx"
 
 namespace sc { namespace opencl {
 
+
+
 }}
-#endif
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

sc/source/core/opencl/op_database.hxx

+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef SC_OPENCL_OP_DATABASE_HXX
+#define SC_OPENCL_OP_DATABASE_HXX
+
+namespace sc { namespace opencl {
+
+
+
+}}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

sc/source/core/opencl/op_financial.hxx

+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef SC_OPENCL_OP_FINANCIAL_HXX
+#define SC_OPENCL_OP_FINANCIAL_HXX
+
+#include "opbase.hxx"
+
+namespace sc { namespace opencl {
+
+class RRI: public SlidingFunctionBase, public OpBase
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+};
+
+class OpRRI:public RRI
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string BinFuncName(void) const { return "RRI"; }
+};
+
+class OpNominal: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "NOMINAL_ADD"; }
+};
+
+class OpDollarde:public Normal
+{
+public:
+        virtual std::string GetBottom(void) { return "0"; }
+
+        virtual void GenSlidingWindowFunction(std::stringstream &ss,
+        const std::string sSymName, SubArguments &vSubArguments);
+
+        virtual std::string BinFuncName(void) const { return "Dollarde"; }
+
+};
+
+class OpDollarfr:public Normal
+{
+public:
+        virtual std::string GetBottom(void) { return "0"; }
+
+        virtual void GenSlidingWindowFunction(std::stringstream &ss,
+        const std::string sSymName, SubArguments &vSubArguments);
+
+        virtual std::string BinFuncName(void) const { return "Dollarfr"; }
+
+};
+
+class OpDISC: public Normal
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+
+    virtual std::string BinFuncName(void) const { return "DISC"; }
+};
+
+class OpINTRATE: public Normal
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+
+    virtual std::string BinFuncName(void) const { return "INTRATE"; }
+};
+
+class Fvschedule: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+};
+
+class Cumipmt: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+};
+
+class IRR: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+};
+
+class OpIRR: public IRR
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string BinFuncName(void) const { return "IRR"; }
+};
+
+class XNPV: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+};
+
+class PriceMat: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+};
+class OpSYD: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+
+     virtual std::string BinFuncName(void) const { return "SYD"; }
+};
+
+class MIRR: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+};
+
+class OpEffective:public Normal
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+        const std::string sSymName, SubArguments &vSubArguments);
+
+    virtual std::string BinFuncName(void) const { return "Effect_Add"; }
+};
+
+class OpCumipmt: public Cumipmt
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string BinFuncName(void) const { return "Cumipmt"; }
+};
+
+class OpXNPV: public XNPV
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string BinFuncName(void) const { return "XNPV"; }
+
+};
+
+class OpTbilleq: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+
+    virtual std::string BinFuncName(void) const { return "fTbilleq"; }
+};
+
+class OpCumprinc: public Normal
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "cumprinc"; }
+};
+
+class OpAccrintm: public Normal
+{
+ public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Accrintm"; }
+};
+
+class OpYield: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Yield"; }
+};
+
+
+class OpSLN: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "SLN"; }
+};
+
+class OpFvschedule: public Fvschedule
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string BinFuncName(void) const { return "Fvschedule"; }
+};
+
+class OpYieldmat: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Yieldmat"; }
+};
+
+class OpPMT: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "PMT"; }
+};
+
+class OpPPMT: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+        const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "PPMT"; }
+};
+
+class OpCoupdaybs:public Normal
+{
+public:
+    virtual std::string GetBottom(void) { return "0";}
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+        const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Coupdaybs"; }
+
+};
+
+class OpCoupdays:public Normal
+{
+public:
+    virtual std::string GetBottom(void) { return "0";}
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+        const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Coupdays";}
+
+};
+
+class OpCoupdaysnc:public Normal
+{
+public:
+    virtual std::string GetBottom(void) { return "0";}
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+        const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Coupdaysnc"; }
+
+};
+
+class OpReceived:public Normal
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+        const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Received"; }
+};
+
+class OpYielddisc: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+        const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Yielddisc"; }
+};
+
+class OpTbillprice: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "fTbillprice"; }
+};
+
+class OpPriceMat:public PriceMat
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string BinFuncName(void) const { return "PriceMat"; }
+};
+
+class RATE: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+};
+class OpIntrate: public RATE {
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string BinFuncName(void) const { return "rate"; }
+};
+
+class OpTbillyield: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+
+    virtual std::string BinFuncName(void) const { return "fTbillyield"; }
+};
+
+class OpMIRR: public MIRR
+{
+public:
+    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string BinFuncName(void) const { return "MIRR"; }
+};
+
+}}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

sc/source/core/opencl/op_math.cxx

@@ -7,16 +7,15 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-#ifndef OP_MATH
-#define OP_MATH
+#include "op_math.hxx"
+
 #include "formulagroup.hxx"
 #include "document.hxx"
 #include "formulacell.hxx"
 #include "tokenarray.hxx"
 #include "compiler.hxx"
 #include "interpre.hxx"
-#include "opbase.hxx"
-#include<list>
+#include <list>
 #include <iostream>
 #include <sstream>
 #include <algorithm>
@@ -25,12 +24,10 @@
 using namespace formula;
 
 namespace sc { namespace opencl {
-class OpCos: public Normal
-{
-public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+
+void OpCos::GenSlidingWindowFunction(std::stringstream &ss,
             const std::string sSymName, SubArguments &vSubArguments)
-    {
+{
     FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     const formula::SingleVectorRefToken*tmpCurDVR= dynamic_cast<const
           formula::SingleVectorRefToken *>(tmpCur);
@@ -55,16 +52,11 @@ public:
     ss << "double tmp=cos(arg0);\n\t";
     ss << "return tmp;\n";
     ss << "}";
-    }
- virtual std::string BinFuncName(void) const { return "Cos"; }
-};
+}
 
-class OpCsc: public Normal
+void OpCsc::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
 {
-public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
     FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     const formula::SingleVectorRefToken*tmpCurDVR= dynamic_cast<const
           formula::SingleVectorRefToken *>(tmpCur);
@@ -89,10 +81,8 @@ public:
     ss << "double tmp=1/sin(arg0);\n\t";
     ss << "return tmp;\n";
     ss << "}";
-    }
- virtual std::string BinFuncName(void) const { return "Csc"; }
-};
+}
+
 }}
-#endif
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

sc/source/core/opencl/op_math.hxx

+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef SC_OPENCL_OP_MATH_HXX
+#define SC_OPENCL_OP_MATH_HXX
+
+#include "opbase.hxx"
+
+namespace sc { namespace opencl {
+
+class OpCos: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+
+    virtual std::string BinFuncName(void) const { return "Cos"; }
+};
+
+class OpCsc: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Csc"; }
+};
+
+}}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

sc/source/core/opencl/op_statistical.cxx

@@ -7,30 +7,27 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-#ifndef OP_STATISTICAL
-#define OP_STATISTICAL
+#include "op_statistical.hxx"
+
 #include "formulagroup.hxx"
 #include "document.hxx"
 #include "formulacell.hxx"
 #include "tokenarray.hxx"
 #include "compiler.hxx"
 #include "interpre.hxx"
-#include "opbase.hxx"
-#include<list>
+#include <list>
 #include <iostream>
 #include <sstream>
 #include <algorithm>
-
-
 #include <memory>
+
 using namespace formula;
 
 namespace sc { namespace opencl {
-class OpFisher:public Normal{
-    public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
+
+void OpFisher::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     const formula::SingleVectorRefToken*tmpCurDVR=
         dynamic_cast<const formula::SingleVectorRefToken *>(tmpCur);
@@ -55,15 +52,11 @@ class OpFisher:public Normal{
     ss << "double tmp=atanh(arg0);\n\t";
     ss << "return tmp;\n";
     ss << "}\n";
-    }
-    virtual std::string BinFuncName(void) const { return "Fisher"; }
-};
+}
 
-class OpFisherInv:public Normal{
-    public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
+void OpFisherInv::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     const formula::SingleVectorRefToken*tmpCurDVR= dynamic_cast<const
           formula::SingleVectorRefToken *>(tmpCur);
@@ -88,15 +81,11 @@ class OpFisherInv:public Normal{
     ss << "double tmp=tanh(arg0);\n\t";
     ss << "return tmp;\n";
     ss << "}\n";
-    }
-    virtual std::string BinFuncName(void) const { return "FisherInv"; }
-};
+}
 
-class OpGamma:public Normal{
-    public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
+void OpGamma::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     ss << "\ndouble " << sSymName;
     ss << "_"<< BinFuncName() <<"(";
     for (unsigned i = 0; i < vSubArguments.size(); i++)
@@ -112,14 +101,11 @@ class OpGamma:public Normal{
     ss << "double tmp=tgamma(arg0);\n\t";
     ss << "return tmp;\n";
     ss << "}\n";
-    }
-    virtual std::string BinFuncName(void) const { return "Gamma"; }
-};
-class OpCorrel:public Normal{
-public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string sSymName, SubArguments &vSubArguments)
-    {
+}
+
+void OpCorrel::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     ss << "\ndouble " << sSymName;
     ss << "_"<< BinFuncName() <<"(";
     for (unsigned i = 0; i < vSubArguments.size(); i++)
@@ -323,14 +309,11 @@ public:
         ss << "}\n";
         ss << "}";
     }
-    }
-    virtual std::string BinFuncName(void) const { return "Correl"; }
-};
-class OpNegbinomdist:public Normal{
-    public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
+}
+
+void OpNegbinomdist::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     ss << "\ndouble " << sSymName;
     ss << "_"<< BinFuncName() <<"(";
     for (unsigned i = 0; i < vSubArguments.size(); i++)
@@ -400,14 +383,11 @@ class OpNegbinomdist:public Normal{
     ss << " double tmp=fFactor;\n\t";
     ss << " return tmp;\n";
     ss << "}\n";
-    }
-    virtual std::string BinFuncName(void) const { return "OpNegbinomdist"; }
-};
-class OpPearson:public Normal{
-    public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
+}
+
+void OpPearson::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     FormulaToken* pCur = vSubArguments[1]->GetFormulaToken();
     assert(pCur);
     const formula::DoubleVectorRefToken* pCurDVR =
@@ -492,14 +472,11 @@ class OpPearson:public Normal{
     ss << "sqrt( fSumSqrDeltaX * fSumSqrDeltaY));\n\t";
     ss << "return tmp;\n";
     ss << "}\n";
-    }
-    virtual std::string BinFuncName(void) const { return "OpPearson"; }
-};
-class OpGammaLn:public Normal{
-    public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
+}
+
+void OpGammaLn::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     const formula::SingleVectorRefToken*tmpCurDVR= dynamic_cast<const
 formula::SingleVectorRefToken *>(tmpCur);
@@ -524,15 +501,11 @@ formula::SingleVectorRefToken *>(tmpCur);
     ss << "double tmp=lgamma(arg0);\n\t";
     ss << "return tmp;\n";
     ss << "}\n";
-    }
-    virtual std::string BinFuncName(void) const { return "GammaLn"; }
-};
+}
 
-class OpGauss:public Normal{
-    public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
+void OpGauss::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     FormulaToken *tmpCur = vSubArguments[0]->GetFormulaToken();
     const formula::SingleVectorRefToken*tmpCurDVR= dynamic_cast<const
                 formula::SingleVectorRefToken *>(tmpCur);
@@ -557,14 +530,11 @@ class OpGauss:public Normal{
     ss << "double tmp=0.5 *erfc(-arg0 * 0.7071067811865475)-0.5;\n\t";
     ss << "return tmp;\n";
     ss << "}\n";
-    }
-    virtual std::string BinFuncName(void) const { return "Gauss"; }
-};
-class OpGeoMean:public Normal{
-    public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
+}
+
+void OpGeoMean::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     FormulaToken *pCur = vSubArguments[0]->GetFormulaToken();
     assert(pCur);
     const formula::DoubleVectorRefToken* pCurDVR =
@@ -599,14 +569,11 @@ class OpGeoMean:public Normal{
     ss<<"tmp = exp(nVal/length);\n\t";
     ss << "return tmp;\n";
     ss << "}";
-    }
-      virtual std::string BinFuncName(void) const { return "GeoMean"; }
-};
-class OpHarMean:public Normal{
-    public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
+}
+
+void OpHarMean::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     FormulaToken *pCur = vSubArguments[0]->GetFormulaToken();
     assert(pCur);
     const formula::DoubleVectorRefToken* pCurDVR =
@@ -640,14 +607,11 @@ class OpHarMean:public Normal{
     ss<<"tmp = length/nVal;\n\t";
     ss << "return tmp;\n";
     ss << "}";
-    }
-      virtual std::string BinFuncName(void) const { return "HarMean"; }
-};
-class OpRsq:public Normal{
-    public:
-    virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string sSymName, SubArguments &vSubArguments)
-    {
+}
+
+void OpRsq::GenSlidingWindowFunction(
+    std::stringstream &ss, const std::string sSymName, SubArguments &vSubArguments)
+{
     FormulaToken* pCur = vSubArguments[1]->GetFormulaToken();
     assert(pCur);
     const formula::DoubleVectorRefToken* pCurDVR =
@@ -729,10 +693,8 @@ class OpRsq:public Normal{
     ss << "double tmp = ( fSumDeltaXDeltaY / sqrt( fSumSqrDeltaX * fSumSqrDeltaY));\n\t";
     ss << "return (tmp * tmp);\n";
     ss << "}\n";
-    }
-    virtual std::string BinFuncName(void) const { return "OpRsq"; }
-};
+}
+
 }}
-#endif
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

sc/source/core/opencl/op_statistical.hxx

+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef SC_OPENCL_OP_STATISTICAL_HXX
+#define SC_OPENCL_OP_STATISTICAL_HXX
+
+#include "opbase.hxx"
+
+namespace sc { namespace opencl {
+
+class OpFisher: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Fisher"; }
+};
+
+class OpFisherInv: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "FisherInv"; }
+};
+
+class OpGamma: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Gamma"; }
+};
+
+class OpCorrel: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+        const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Correl"; }
+};
+
+class OpNegbinomdist: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "OpNegbinomdist"; }
+};
+
+class OpPearson: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "OpPearson"; }
+};
+
+class OpGammaLn: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "GammaLn"; }
+};
+
+class OpGauss: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "Gauss"; }
+};
+
+class OpGeoMean: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "GeoMean"; }
+};
+
+class OpHarMean: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "HarMean"; }
+};
+
+class OpRsq: public Normal
+{
+public:
+    virtual void GenSlidingWindowFunction(std::stringstream &ss,
+            const std::string sSymName, SubArguments &vSubArguments);
+    virtual std::string BinFuncName(void) const { return "OpRsq"; }
+};
+
+}}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

sc/source/core/opencl/opbase.hxx

@@ -7,16 +7,20 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-#ifndef OPBASE
-#define OPBASE
+#ifndef SC_OPENCL_OPBASE_HXX
+#define SC_OPENCL_OPBASE_HXX
+
 #include "formulagroup.hxx"
 #include "document.hxx"
 #include "formulacell.hxx"
 #include "tokenarray.hxx"
 #include "compiler.hxx"
 #include "interpre.hxx"
+#include "formula/vectortoken.hxx"
+
+#include "clcc/clew.h"
 
-#include<list>
+#include <list>
 #include <iostream>
 #include <sstream>
 #include <algorithm>