platform/symbian/MathUtilsSymbian.cpp

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is [Open Source Virtual Machine.].
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Adobe System Incorporated.
  18  * Portions created by the Initial Developer are Copyright (C) 2004-2007
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *   Adobe AS3 Team
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #include <e32math.h>
  39 #include <math.h> // no Symbian equivalent of frexp, ceil, floor.
  40
  41 #include "avmplus.h"
  42
  43 namespace avmplus
  44 {
  45         double MathUtils::abs(double value)
  46         {
  47                 return ::fabs(value);
  48         }
  49
  50         double MathUtils::acos(double value)
  51         {
  52                 double result;
  53                 Math::ACos(result, value);
  54                 return result;
  55         }
  56
  57         double MathUtils::asin(double value)
  58         {
  59                 double result;
  60                 Math::ASin(result, value);
  61                 return result;
  62         }
  63
  64         double MathUtils::atan(double value)
  65         {
  66                 double result;
  67                 Math::ATan(result, value);
  68                 return result;
  69         }
  70
  71         double MathUtils::atan2(double y, double x)
  72         {
  73                 bool xnan = (((int*)(&x))[1] & 0x7FF80000) == 0x7FF80000;
  74                 bool ynan = (((int*)(&y))[1] & 0x7FF80000) == 0x7FF80000;
  75
  76                 if (xnan || ynan)
  77                 {
  78                         return nan();
  79                 }
  80
  81                 int sx = (((int*)(&x))[1] & 0x80000000);
  82                 int sy = (((int*)(&y))[1] & 0x80000000);
  83
  84                 if (y == 0.0)
  85                 {
  86                         if (sy) // y is -0
  87                         {
  88                                 if (sx) // x is <0 or -0
  89                                 {
  90                                         return -KPi;
  91                                 }
  92                                 else // x is >0 or +0
  93                                 {
  94                                         return -0.0;
  95                                 }
  96                         }
  97                         else // y is +0
  98                         {
  99                                 if (sx) // x is <0 or -0
 100                                 {
 101                                         return KPi;
 102                                 }
 103                                 else // x is >0 or +0
 104                                 {
 105                                         return +0.0;
 106                                 }
 107                         }
 108                 }
 109                 double result;
 110                 Math::ATan(result, y, x);
 111                 return result;
 112         }
 113
 114         double MathUtils::ceil(double value)
 115         {
 116                 return ::ceil(value);
 117         }
 118
 119         double MathUtils::cos(double value)
 120         {
 121                 double result;
 122                 Math::Cos(result, value);
 123                 return result;
 124         }
 125
 126         double MathUtils::exp(double value)
 127         {
 128                 double result;
 129                 Math::Exp(result, value);
 130                 return result;
 131         }
 132
 133         double MathUtils::floor(double value)
 134         {
 135                 return ::floor(value);
 136         }
 137
 138         uint64_t MathUtils::frexp(double value, int *eptr)
 139         {
 140                 double fracMantissa = ::frexp(value, eptr);
 141                 // correct mantissa and eptr to get integer values for both
 142                 *eptr -= 53; // 52 mantissa bits + the hidden bit
 143                 return (uint64_t)(fracMantissa * (double)(1LL << 53));
 144         }
 145
 146         // The log function wants the natural log, not the base 10 log.
 147         double MathUtils::log(double value)
 148         {
 149                 double result;
 150                 Math::Ln(result, value);
 151                 return result;
 152         }
 153
 154         double fmod(double x, double y)
 155         {
 156                 double result;
 157                 Math::Mod(result, x, y);
 158                 return result;
 159         }
 160
 161         double MathUtils::mod(double x, double y)
 162         {
 163                 double result;
 164                 Math::Mod(result, x, y);
 165                 return result;
 166         }
 167
 168         double MathUtils::powInternal(double x, double y)
 169         {
 170                 double result;
 171                 Math::Pow(result, x, y);
 172                 return result;
 173         }
 174
 175         double MathUtils::sin(double value)
 176         {
 177                 double result;
 178                 Math::Sin(result, value);
 179                 return result;
 180         }
 181
 182         double MathUtils::sqrt(double value)
 183         {
 184                 double result;
 185                 Math::Sqrt(result, value);
 186                 return result;
 187         }
 188
 189         double MathUtils::tan(double value)
 190         {
 191                 double result;
 192                 Math::Tan(result, value);
 193                 return result;
 194         }
 195 }