connectivity/source/inc/file/FNumericFunctions.hxx

   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         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         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         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         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         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         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         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         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         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         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         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         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         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         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         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         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         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         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         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         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         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         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: */