LCOV - code coverage report
Current view: top level - connectivity/source/inc/file - FNumericFunctions.hxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 0 22 0.0 %
Date: 2015-06-13 12:38:46 Functions: 0 66 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #ifndef INCLUDED_CONNECTIVITY_SOURCE_INC_FILE_FNUMERICFUNCTIONS_HXX
      21             : #define INCLUDED_CONNECTIVITY_SOURCE_INC_FILE_FNUMERICFUNCTIONS_HXX
      22             : 
      23             : #include "file/fcode.hxx"
      24             : #include "file/filedllapi.hxx"
      25             : 
      26             : namespace connectivity
      27             : {
      28             :     namespace file
      29             :     {
      30             :         /** ABS(X)
      31             :             Returns the absolute value of X:
      32             : 
      33             :         > SELECT ABS(2);
      34             :                 -> 2
      35             :         > SELECT ABS(-32);
      36             :                 -> 32
      37             : 
      38             :         */
      39           0 :         class OOp_Abs : public OUnaryOperator
      40             :         {
      41             :         protected:
      42             :             virtual ORowSetValue operate(const ORowSetValue& lhs) const SAL_OVERRIDE;
      43             :         };
      44             : 
      45             :         /** SIGN(X)
      46             :             Returns the sign of the argument as -1, 0, or 1, depending on whether X is negative, zero, or positive:
      47             : 
      48             :             > SELECT SIGN(-32);
      49             :                     -> -1
      50             :             > SELECT SIGN(0);
      51             :                     -> 0
      52             :             > SELECT SIGN(234);
      53             :                     -> 1
      54             : 
      55             :         */
      56           0 :         class OOp_Sign : public OUnaryOperator
      57             :         {
      58             :         protected:
      59             :             virtual ORowSetValue operate(const ORowSetValue& lhs) const SAL_OVERRIDE;
      60             :         };
      61             : 
      62             :         /** MOD(N,M)
      63             :             %
      64             :                 Modulo (like the % operator in C). Returns the remainder of N divided by M:
      65             : 
      66             :             > SELECT MOD(234, 10);
      67             :                     -> 4
      68             :             > SELECT 253 % 7;
      69             :                     -> 1
      70             :             > SELECT MOD(29,9);
      71             :                     -> 2
      72             :             > SELECT 29 MOD 9;
      73             :                     -> 2
      74             :         */
      75           0 :         class OOp_Mod : public OBinaryOperator
      76             :         {
      77             :         protected:
      78             :             virtual ORowSetValue operate(const ORowSetValue& lhs,const ORowSetValue& rhs) const SAL_OVERRIDE;
      79             :         };
      80             : 
      81             :         /** FLOOR(X)
      82             :             Returns the largest integer value not greater than X:
      83             : 
      84             :         > SELECT FLOOR(1.23);
      85             :                 -> 1
      86             :         > SELECT FLOOR(-1.23);
      87             :                 -> -2
      88             : 
      89             :         */
      90           0 :         class OOp_Floor : public OUnaryOperator
      91             :         {
      92             :         protected:
      93             :             virtual ORowSetValue operate(const ORowSetValue& lhs) const SAL_OVERRIDE;
      94             :         };
      95             : 
      96             :         /** CEILING(X)
      97             :             Returns the smallest integer value not less than X:
      98             : 
      99             :         > SELECT CEILING(1.23);
     100             :                 -> 2
     101             :         > SELECT CEILING(-1.23);
     102             :                 -> -1
     103             : 
     104             :         */
     105           0 :         class OOp_Ceiling : public OUnaryOperator
     106             :         {
     107             :         protected:
     108             :             virtual ORowSetValue operate(const ORowSetValue& lhs) const SAL_OVERRIDE;
     109             :         };
     110             : 
     111             :         /** ROUND(X)
     112             :             ROUND(X,D)
     113             :             Returns the argument X, rounded to the nearest integer. With two arguments rounded to a number to D decimals.
     114             : 
     115             :             > SELECT ROUND(-1.23);
     116             :                     -> -1
     117             :             > SELECT ROUND(-1.58);
     118             :                     -> -2
     119             :             > SELECT ROUND(1.58);
     120             :                     -> 2
     121             :             > SELECT ROUND(1.298, 1);
     122             :                     -> 1.3
     123             :             > SELECT ROUND(1.298, 0);
     124             :                     -> 1
     125             :             > SELECT ROUND(23.298, -1);
     126             :                     -> 20
     127             :         */
     128           0 :         class OOp_Round : public ONthOperator
     129             :         {
     130             :         protected:
     131             :             virtual ORowSetValue operate(const ::std::vector<ORowSetValue>& lhs) const SAL_OVERRIDE;
     132             :         };
     133             : 
     134             :         /** EXP(X)
     135             :             Returns the value of e (the base of natural logarithms) raised to the power of X:
     136             : 
     137             :         > SELECT EXP(2);
     138             :                 -> 7.389056
     139             :         > SELECT EXP(-2);
     140             :                 -> 0.135335
     141             :         */
     142           0 :         class OOp_Exp : public OUnaryOperator
     143             :         {
     144             :         protected:
     145             :             virtual ORowSetValue operate(const ORowSetValue& lhs) const SAL_OVERRIDE;
     146             :         };
     147             : 
     148             :         /** LN(X)
     149             :             Returns the natural logarithm of X:
     150             : 
     151             :         > SELECT LN(2);
     152             :                 -> 0.693147
     153             :         > SELECT LN(-2);
     154             :                 -> NULL
     155             : 
     156             :         */
     157           0 :         class OOp_Ln : public OUnaryOperator
     158             :         {
     159             :         protected:
     160             :             virtual ORowSetValue operate(const ORowSetValue& lhs) const SAL_OVERRIDE;
     161             :         };
     162             : 
     163             :         /** LOG(X)
     164             :             LOG(B,X)
     165             :                 If called with one parameter, this function returns the natural logarithm of X:
     166             : 
     167             :             > SELECT LOG(2);
     168             :                     -> 0.693147
     169             :             > SELECT LOG(-2);
     170             :                     -> NULL
     171             : 
     172             :                 If called with two parameters, this function returns the logarithm of X for an arbitrary base B:
     173             : 
     174             :             > SELECT LOG(2,65536);
     175             :                     -> 16.000000
     176             :             > SELECT LOG(1,100);
     177             :                     -> NULL
     178             :         */
     179           0 :         class OOp_Log : public ONthOperator
     180             :         {
     181             :         protected:
     182             :             virtual ORowSetValue operate(const ::std::vector<ORowSetValue>& lhs) const SAL_OVERRIDE;
     183             :         };
     184             : 
     185             :         /** LOG10(X)
     186             :             Returns the base-10 logarithm of X:
     187             : 
     188             :         > SELECT LOG10(2);
     189             :                 -> 0.301030
     190             :         > SELECT LOG10(100);
     191             :                 -> 2.000000
     192             :         > SELECT LOG10(-100);
     193             :                 -> NULL
     194             :         */
     195           0 :         class OOp_Log10 : public OUnaryOperator
     196             :         {
     197             :         protected:
     198             :             virtual ORowSetValue operate(const ORowSetValue& lhs) const SAL_OVERRIDE;
     199             :         };
     200             : 
     201             :         /** POWER(X,Y)
     202             :                 Returns the value of X raised to the power of Y:
     203             : 
     204             :             > SELECT POW(2,2);
     205             :                     -> 4.000000
     206             :             > SELECT POW(2,-2);
     207             :                     -> 0.250000
     208             :         */
     209           0 :         class OOp_Pow : public OBinaryOperator
     210             :         {
     211             :         protected:
     212             :             virtual ORowSetValue operate(const ORowSetValue& lhs,const ORowSetValue& rhs) const SAL_OVERRIDE;
     213             :         };
     214             : 
     215             :         /** SQRT(X)
     216             :             Returns the non-negative square root of X:
     217             : 
     218             :         > SELECT SQRT(4);
     219             :                 -> 2.000000
     220             :         > SELECT SQRT(20);
     221             :                 -> 4.472136
     222             :         */
     223           0 :         class OOp_Sqrt : public OUnaryOperator
     224             :         {
     225             :         protected:
     226             :             virtual ORowSetValue operate(const ORowSetValue& lhs) const SAL_OVERRIDE;
     227             :         };
     228             : 
     229             :         /** PI()
     230             :             Returns the value of PI. The default shown number of decimals is 5, but  internally uses the full double precession for PI.
     231             : 
     232             :         > SELECT PI();
     233             :                 -> 3.141593
     234             :         > SELECT PI()+0.000000000000000000;
     235             :                 -> 3.141592653589793238
     236             : 
     237             :         */
     238           0 :         class OOp_Pi : public ONthOperator
     239             :         {
     240             :         protected:
     241             :             virtual ORowSetValue operate(const ::std::vector<ORowSetValue>& lhs) const SAL_OVERRIDE;
     242             :         };
     243             : 
     244             :         /** COS(X)
     245             :             Returns the cosine of X, where X is given in radians:
     246             : 
     247             :         > SELECT COS(PI());
     248             :                 -> -1.000000
     249             :         */
     250           0 :         class OOp_Cos : public OUnaryOperator
     251             :         {
     252             :         protected:
     253             :             virtual ORowSetValue operate(const ORowSetValue& lhs = ORowSetValue()) const SAL_OVERRIDE;
     254             :         };
     255             : 
     256             :         /** SIN(X)
     257             :             Returns the sine of X, where X is given in radians:
     258             : 
     259             :         > SELECT SIN(PI());
     260             :                 -> 0.000000
     261             : 
     262             :         */
     263           0 :         class OOp_Sin : public OUnaryOperator
     264             :         {
     265             :         protected:
     266             :             virtual ORowSetValue operate(const ORowSetValue& lhs = ORowSetValue()) const SAL_OVERRIDE;
     267             :         };
     268             :         /** TAN(X)
     269             :             Returns the tangent of X, where X is given in radians:
     270             : 
     271             :         > SELECT TAN(PI()+1);
     272             :                 -> 1.557408
     273             :         */
     274           0 :         class OOp_Tan : public OUnaryOperator
     275             :         {
     276             :         protected:
     277             :             virtual ORowSetValue operate(const ORowSetValue& lhs = ORowSetValue()) const SAL_OVERRIDE;
     278             :         };
     279             : 
     280             :         /** ACOS(X)
     281             :             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:
     282             : 
     283             :         > SELECT ACOS(1);
     284             :                 -> 0.000000
     285             :         > SELECT ACOS(1.0001);
     286             :                 -> NULL
     287             :         > SELECT ACOS(0);
     288             :                 -> 1.570796
     289             :         */
     290           0 :         class OOp_ACos : public OUnaryOperator
     291             :         {
     292             :         protected:
     293             :             virtual ORowSetValue operate(const ORowSetValue& lhs = ORowSetValue()) const SAL_OVERRIDE;
     294             :         };
     295             : 
     296             :         /** ASIN(X)
     297             :             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:
     298             : 
     299             :         > SELECT ASIN(0.2);
     300             :                 -> 0.201358
     301             :         > SELECT ASIN('foo');
     302             :                 -> 0.000000
     303             :         */
     304           0 :         class OOp_ASin : public OUnaryOperator
     305             :         {
     306             :         protected:
     307             :             virtual ORowSetValue operate(const ORowSetValue& lhs = ORowSetValue()) const SAL_OVERRIDE;
     308             :         };
     309             : 
     310             :         /** ATAN(X)
     311             :             Returns the arc tangent of X, that is, the value whose tangent is X:
     312             : 
     313             :         > SELECT ATAN(2);
     314             :                 -> 1.107149
     315             :         > SELECT ATAN(-2);
     316             :                 -> -1.107149
     317             :         */
     318           0 :         class OOp_ATan : public OUnaryOperator
     319             :         {
     320             :         protected:
     321             :             virtual ORowSetValue operate(const ORowSetValue& lhs = ORowSetValue()) const SAL_OVERRIDE;
     322             :         };
     323             : 
     324             :         /** ATAN2(Y,X)
     325             :             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:
     326             : 
     327             :         > SELECT ATAN2(-2,2);
     328             :                 -> -0.785398
     329             :         > SELECT ATAN2(PI(),0);
     330             :                 -> 1.570796
     331             : 
     332             :         */
     333           0 :         class OOp_ATan2 : public OBinaryOperator
     334             :         {
     335             :         protected:
     336             :             virtual ORowSetValue operate(const ORowSetValue& lhs,const ORowSetValue& rhs) const SAL_OVERRIDE;
     337             :         };
     338             : 
     339             :         /** DEGREES(X)
     340             :             Returns the argument X, converted from radians to degrees:
     341             : 
     342             :         > SELECT DEGREES(PI());
     343             :                 -> 180.000000
     344             :         */
     345           0 :         class OOp_Degrees : public OUnaryOperator
     346             :         {
     347             :         protected:
     348             :             virtual ORowSetValue operate(const ORowSetValue& lhs = ORowSetValue()) const SAL_OVERRIDE;
     349             :         };
     350             : 
     351             :         /** RADIANS(X)
     352             :             Returns the argument X, converted from degrees to radians:
     353             : 
     354             :         > SELECT RADIANS(90);
     355             :                 -> 1.570796
     356             : 
     357             :         */
     358           0 :         class OOp_Radians : public OUnaryOperator
     359             :         {
     360             :         protected:
     361             :             virtual ORowSetValue operate(const ORowSetValue& lhs = ORowSetValue()) const SAL_OVERRIDE;
     362             :         };
     363             :     }
     364             : }
     365             : 
     366             : #endif // INCLUDED_CONNECTIVITY_SOURCE_INC_FILE_FNUMERICFUNCTIONS_HXX
     367             : 
     368             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11