/* -*- 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/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#pragma once

#include <file/fcode.hxx>

namespace connectivity::file
{
    /** ABS(X)
        Returns the absolute value of X:

    > SELECT ABS(2);
            -> 2
    > SELECT ABS(-32);
            -> 32

    */
    class OOp_Abs : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** SIGN(X)
        Returns the sign of the argument as -1, 0, or 1, depending on whether X is negative, zero, or positive:

        > SELECT SIGN(-32);
                -> -1
        > SELECT SIGN(0);
                -> 0
        > SELECT SIGN(234);
                -> 1

    */
    class OOp_Sign : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** MOD(N,M)
        %
            Modulo (like the % operator in C). Returns the remainder of N divided by M:

        > SELECT MOD(234, 10);
                -> 4
        > SELECT 253 % 7;
                -> 1
        > SELECT MOD(29,9);
                -> 2
        > SELECT 29 MOD 9;
                -> 2
    */
    class OOp_Mod : public OBinaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs,const ORowSetValue& rhs) const override;
    };

    /** FLOOR(X)
        Returns the largest integer value not greater than X:

    > SELECT FLOOR(1.23);
            -> 1
    > SELECT FLOOR(-1.23);
            -> -2

    */
    class OOp_Floor : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** CEILING(X)
        Returns the smallest integer value not less than X:

    > SELECT CEILING(1.23);
            -> 2
    > SELECT CEILING(-1.23);
            -> -1

    */
    class OOp_Ceiling : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** ROUND(X)
        ROUND(X,D)
        Returns the argument X, rounded to the nearest integer. With two arguments rounded to a number to D decimals.

        > SELECT ROUND(-1.23);
                -> -1
        > SELECT ROUND(-1.58);
                -> -2
        > SELECT ROUND(1.58);
                -> 2
        > SELECT ROUND(1.298, 1);
                -> 1.3
        > SELECT ROUND(1.298, 0);
                -> 1
        > SELECT ROUND(23.298, -1);
                -> 20
    */
    class OOp_Round : public ONthOperator
    {
    protected:
        virtual ORowSetValue operate(const std::vector<ORowSetValue>& lhs) const override;
    };

    /** EXP(X)
        Returns the value of e (the base of natural logarithms) raised to the power of X:

    > SELECT EXP(2);
            -> 7.389056
    > SELECT EXP(-2);
            -> 0.135335
    */
    class OOp_Exp : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** LN(X)
        Returns the natural logarithm of X:

    > SELECT LN(2);
            -> 0.693147
    > SELECT LN(-2);
            -> NULL

    */
    class OOp_Ln : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** LOG(X)
        LOG(B,X)
            If called with one parameter, this function returns the natural logarithm of X:

        > SELECT LOG(2);
                -> 0.693147
        > SELECT LOG(-2);
                -> NULL

            If called with two parameters, this function returns the logarithm of X for an arbitrary base B:

        > SELECT LOG(2,65536);
                -> 16.000000
        > SELECT LOG(1,100);
                -> NULL
    */
    class OOp_Log : public ONthOperator
    {
    protected:
        virtual ORowSetValue operate(const std::vector<ORowSetValue>& lhs) const override;
    };

    /** LOG10(X)
        Returns the base-10 logarithm of X:

    > SELECT LOG10(2);
            -> 0.301030
    > SELECT LOG10(100);
            -> 2.000000
    > SELECT LOG10(-100);
            -> NULL
    */
    class OOp_Log10 : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** POWER(X,Y)
            Returns the value of X raised to the power of Y:

        > SELECT POW(2,2);
                -> 4.000000
        > SELECT POW(2,-2);
                -> 0.250000
    */
    class OOp_Pow : public OBinaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs,const ORowSetValue& rhs) const override;
    };

    /** SQRT(X)
        Returns the non-negative square root of X:

    > SELECT SQRT(4);
            -> 2.000000
    > SELECT SQRT(20);
            -> 4.472136
    */
    class OOp_Sqrt : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** PI()
        Returns the value of PI. The default shown number of decimals is 5, but  internally uses the full double precision for PI.

    > SELECT PI();
            -> 3.141593
    > SELECT PI()+0.000000000000000000;
            -> 3.141592653589793238

    */
    class OOp_Pi : public ONthOperator
    {
    protected:
        virtual ORowSetValue operate(const std::vector<ORowSetValue>& lhs) const override;
    };

    /** COS(X)
        Returns the cosine of X, where X is given in radians:

    > SELECT COS(PI());
            -> -1.000000
    */
    class OOp_Cos : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** SIN(X)
        Returns the sine of X, where X is given in radians:

    > SELECT SIN(PI());
            -> 0.000000

    */
    class OOp_Sin : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };
    /** TAN(X)
        Returns the tangent of X, where X is given in radians:

    > SELECT TAN(PI()+1);
            -> 1.557408
    */
    class OOp_Tan : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** ACOS(X)
        Returns the arc cosine of X, that is, the value whose cosine is X. Returns NULL if X is not in the range -1 to 1:

    > SELECT ACOS(1);
            -> 0.000000
    > SELECT ACOS(1.0001);
            -> NULL
    > SELECT ACOS(0);
            -> 1.570796
    */
    class OOp_ACos : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** ASIN(X)
        Returns the arc sine of X, that is, the value whose sine is X. Returns NULL if X is not in the range -1 to 1:

    > SELECT ASIN(0.2);
            -> 0.201358
    > SELECT ASIN('foo');
            -> 0.000000
    */
    class OOp_ASin : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** ATAN(X)
        Returns the arc tangent of X, that is, the value whose tangent is X:

    > SELECT ATAN(2);
            -> 1.107149
    > SELECT ATAN(-2);
            -> -1.107149
    */
    class OOp_ATan : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** ATAN2(Y,X)
        Returns the arc tangent of the two variables X and Y. It is similar to calculating the arc tangent of Y / X, except that the signs of both arguments are used to determine the quadrant of the result:

    > SELECT ATAN2(-2,2);
            -> -0.785398
    > SELECT ATAN2(PI(),0);
            -> 1.570796

    */
    class OOp_ATan2 : public OBinaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs,const ORowSetValue& rhs) const override;
    };

    /** DEGREES(X)
        Returns the argument X, converted from radians to degrees:

    > SELECT DEGREES(PI());
            -> 180.000000
    */
    class OOp_Degrees : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

    /** RADIANS(X)
        Returns the argument X, converted from degrees to radians:

    > SELECT RADIANS(90);
            -> 1.570796

    */
    class OOp_Radians : public OUnaryOperator
    {
    protected:
        virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
    };

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */