op_math.hxx

Go to the documentation of this file.

/* -*- 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/.
 */
 
#pragma once
 
#include "opbase.hxx"
#include "utils.hxx"
 
namespace sc::opencl {
 
class OpMathOneArgument : public Normal
{
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual void GenerateCode( outputstream& ss ) const = 0;
};
 
class OpMathTwoArguments : public Normal
{
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual void GenerateCode( outputstream& ss ) const = 0;
};
 
 
class OpCos: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Cos"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpSec: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Sec"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpSecH: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "SecH"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpMROUND: public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "MROUND"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpCsc: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Csc"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpSumIfs final : public CheckVariables
{
public:
    OpSumIfs(): CheckVariables(), mNeedReductionKernel(false) {}
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "SumIfs"; }
    bool NeedReductionKernel() const { return mNeedReductionKernel; }
private:
    bool mNeedReductionKernel;
};
 
class OpCosh: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Cosh"; }
    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) override;
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpSinh: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Sinh"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpSin: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Sin"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpAbs: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "ScAbs"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpArcCos: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "ScACos"; }
    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) override;
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpArcCosHyp : public OpMathOneArgument
{
public:
    virtual std::string GetBottom() override { return "1.0"; }
    virtual std::string BinFuncName() const override { return "ScACosH"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpTan: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Tan"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpTanH: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "TanH"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpSqrt: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Sqrt"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpArcCot : public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "ScACot"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpArcCotHyp : public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "ScACotH"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpArcSin : public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "ScASin"; }
    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) override;
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpArcSinHyp : public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "ScASinH"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpArcTan2 : public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "ScATan2"; }
    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) override;
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpArcTan : public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "ScATan"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpArcTanH : public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "ScATanH"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpBitAnd : public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "ScBitAnd"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpBitOr : public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "ScBitOr"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpBitXor : public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "ScBitXor"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpBitLshift : public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "ScBitLshift"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpBitRshift : public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "ScBitRshift"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpLn: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Ln"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpRound: public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "Round"; }
    virtual void BinInlineFun(std::set<std::string>& , std::set<std::string>& ) override;
};
class OpRoundUp: public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "RoundUp"; }
};
class OpRoundDown: public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "RoundDown"; }
};
class OpTrunc: public OpRoundDown
{
public:
    virtual std::string BinFuncName() const override { return "Trunc"; }
};
class OpInt: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Int"; }
    virtual void GenerateCode( outputstream& ss ) const override;
    virtual void BinInlineFun(std::set<std::string>& , std::set<std::string>& ) override;
};
 
class OpRadians: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Radians"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpIsEven: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "IsEven"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpIsOdd: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "IsOdd"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpCot: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Cot"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpSumSQ: public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
 
    virtual std::string BinFuncName() const override { return "SumSQ"; }
    virtual bool canHandleMultiVector() const override { return true; }
};
 
class OpCoth: public OpMathOneArgument
{
public:
    virtual void BinInlineFun(std::set<std::string>& ,
            std::set<std::string>& ) override;
    virtual std::string BinFuncName() const override { return "Coth"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpPower: public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "Power"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpOdd: public OpMathOneArgument
{
public:
    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) override;
    virtual std::string BinFuncName() const override { return "Odd"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpFloor: public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
        const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "Floor"; }
};
 
class OpCscH: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "CscH"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpCeil:public Normal{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
        const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string GetBottom() override { return "0.0"; }
    virtual std::string BinFuncName() const override { return "ScCeil"; }
};
 
class OpExp: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Exp"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpLog10: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Log10"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpEven: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Even"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpAverageIfs: public CheckVariables
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "AverageIfs"; }
};
class OpCountIfs: public CheckVariables
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "CountIfs"; }
};
class OpMod: public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "Mod"; }
    virtual void GenerateCode( outputstream& ss ) const override;
    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) override;
};
 
class OpProduct: public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
        const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "Product"; }
    virtual bool canHandleMultiVector() const override { return true; }
};
 
class OpSqrtPi: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "SqrtPi"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpCombinA: public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "Combina"; }
    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) override;
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpLog: public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
 
    virtual std::string BinFuncName() const override { return "Log"; }
};
 
class OpCombin: public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "ScCombin"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpAverageIf: public CheckVariables
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
        const std::string &sSymName, SubArguments &vSubArguments) override;
 
    virtual std::string BinFuncName() const override { return "AverageIf"; }
};
class OpDeg: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Degrees"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpCountIf: public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "Countif"; }
};
class OpFact : public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "Fact"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpSeriesSum: public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "SeriesSum"; }
    virtual bool canHandleMultiVector() const override { return true; }
};
class OpSumIf: public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "SumIf"; }
};
 
class OpQuotient: public OpMathTwoArguments
{
public:
    virtual std::string BinFuncName() const override { return "Quotient"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpNegSub: public OpMathOneArgument
{
public:
    virtual std::string BinFuncName() const override { return "NegSub"; }
    virtual void GenerateCode( outputstream& ss ) const override;
};
 
class OpEqual : public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "eq"; }
    virtual void BinInlineFun(std::set<std::string>& , std::set<std::string>& ) override;
    virtual bool takeString() const override { return true; }
};
 
class OpNotEqual : public Normal
{
public:
    virtual void GenSlidingWindowFunction(outputstream &ss,
            const std::string &sSymName, SubArguments &vSubArguments) override;
    virtual std::string BinFuncName() const override { return "neq"; }
    virtual void BinInlineFun(std::set<std::string>& , std::set<std::string>& ) override;
    virtual bool takeString() const override { return true; }
};
 
class OpLessEqual : public OpMathTwoArguments
{
public:
    virtual void GenerateCode( outputstream& ss ) const override;
    virtual std::string BinFuncName() const override { return "le"; }
    virtual void BinInlineFun(std::set<std::string>& , std::set<std::string>& ) override;
};
 
class OpLess : public OpMathTwoArguments
{
public:
    virtual void GenerateCode( outputstream& ss ) const override;
    virtual std::string BinFuncName() const override { return "lt"; }
};
 
class OpGreaterEqual : public OpMathTwoArguments
{
public:
    virtual void GenerateCode( outputstream& ss ) const override;
    virtual std::string BinFuncName() const override { return "ge"; }
    virtual void BinInlineFun(std::set<std::string>& , std::set<std::string>& ) override;
};
 
class OpGreater : public OpMathTwoArguments
{
public:
    virtual void GenerateCode( outputstream& ss ) const override;
    virtual std::string BinFuncName() const override { return "gt"; }
};
 
class SumOfProduct : public SlidingFunctionBase
{
public:
    virtual void GenSlidingWindowFunction( outputstream& ss,
        const std::string& sSymName, SubArguments& vSubArguments ) override;
    virtual bool takeString() const override { return false; }
    virtual bool takeNumeric() const override { return true; }
};
 
class OpSumProduct : public SumOfProduct
{
public:
    virtual std::string Gen2( const std::string& lhs, const std::string& rhs ) const override
    {
        return lhs + "*" + rhs;
    }
    virtual std::string BinFuncName() const override { return "fsop"; }
};
 
class OpNop : public Reduction
{
public:
    explicit OpNop(int nResultSize) : Reduction(nResultSize) {}
 
    virtual std::string GetBottom() override { return "0"; }
    virtual std::string Gen2( const std::string& lhs, const std::string& ) const override
    {
        return lhs;
    }
    virtual std::string BinFuncName() const override { return "nop"; }
};
 
class OpSum : public Reduction
{
public:
    explicit OpSum(int nResultSize) : Reduction(nResultSize) {}
 
    virtual std::string GetBottom() override { return "0"; }
    virtual std::string Gen2( const std::string& lhs, const std::string& rhs ) const override
    {
        outputstream ss;
        ss << "fsum_approx((" << lhs << "),(" << rhs << "))";
        return ss.str();
    }
    virtual void BinInlineFun(std::set<std::string>& decls,std::set<std::string>& funs) override;
    virtual std::string BinFuncName() const override { return "fsum"; }
    // All arguments are simply summed, so it doesn't matter if SvDoubleVector is split.
    virtual bool canHandleMultiVector() const override { return true; }
};
 
class OpSub : public Reduction
{
public:
    explicit OpSub(int nResultSize) : Reduction(nResultSize) {}
 
    virtual std::string GetBottom() override { return "0"; }
    virtual std::string Gen2( const std::string& lhs, const std::string& rhs ) const override
    {
        return "fsub_approx(" + lhs + "," + rhs + ")";
    }
    virtual void BinInlineFun(std::set<std::string>& decls,std::set<std::string>& funs) override;
    virtual std::string BinFuncName() const override { return "fsub"; }
};
 
class OpMul : public Reduction
{
public:
    explicit OpMul(int nResultSize) : Reduction(nResultSize) {}
 
    virtual std::string GetBottom() override { return "1"; }
    virtual std::string Gen2( const std::string& lhs, const std::string& rhs ) const override
    {
        return lhs + "*" + rhs;
    }
    virtual std::string BinFuncName() const override { return "fmul"; }
    virtual bool ZeroReturnZero() override { return true; }
};
 
class OpDiv : public Reduction
{
public:
    explicit OpDiv(int nResultSize) : Reduction(nResultSize) {}
 
    virtual std::string GetBottom() override { return "1.0"; }
    virtual std::string Gen2( const std::string& lhs, const std::string& rhs ) const override
    {
        return "(" + rhs + "==0 ? CreateDoubleError(DivisionByZero) : (" + lhs + "/" + rhs + ") )";
    }
    virtual std::string BinFuncName() const override { return "fdiv"; }
 
    virtual bool HandleNaNArgument( outputstream& ss, unsigned argno, SubArguments& vSubArguments ) const override
    {
        if (argno == 1)
        {
            ss <<
                "if (isnan(" << vSubArguments[argno]->GenSlidingWindowDeclRef() << ")) {\n"
                "    return CreateDoubleError(DivisionByZero);\n"
                "}\n";
            return true;
        }
        else if (argno == 0)
        {
            ss <<
                "if (isnan(" << vSubArguments[argno]->GenSlidingWindowDeclRef() << ") &&\n"
                "    !(isnan(" << vSubArguments[1]->GenSlidingWindowDeclRef() << ") || " << vSubArguments[1]->GenSlidingWindowDeclRef() << " == 0)) {\n"
                "    return 0;\n"
                "}\n";
        }
        return false;
    }
 
};
 
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */