connectivity/source/inc/file/FNumericFunctions.hxx

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