source/src/ring_vmmath.c

   1 /* Copyright (c) 2013-2019 Mahmoud Fayed <msfclipper@yahoo.com> */
   2 #include "ring.h"
   3 /* Functions */
   4
   5 void ring_vm_math_loadfunctions ( RingState *pRingState )
   6 {
   7         ring_vm_funcregister("sin",ring_vm_math_sin);
   8         ring_vm_funcregister("cos",ring_vm_math_cos);
   9         ring_vm_funcregister("tan",ring_vm_math_tan);
  10         ring_vm_funcregister("asin",ring_vm_math_asin);
  11         ring_vm_funcregister("acos",ring_vm_math_acos);
  12         ring_vm_funcregister("atan",ring_vm_math_atan);
  13         ring_vm_funcregister("atan2",ring_vm_math_atan2);
  14         ring_vm_funcregister("sinh",ring_vm_math_sinh);
  15         ring_vm_funcregister("cosh",ring_vm_math_cosh);
  16         ring_vm_funcregister("tanh",ring_vm_math_tanh);
  17         ring_vm_funcregister("exp",ring_vm_math_exp);
  18         ring_vm_funcregister("log",ring_vm_math_log);
  19         ring_vm_funcregister("log10",ring_vm_math_log10);
  20         ring_vm_funcregister("ceil",ring_vm_math_ceil);
  21         ring_vm_funcregister("floor",ring_vm_math_floor);
  22         ring_vm_funcregister("fabs",ring_vm_math_fabs);
  23         ring_vm_funcregister("pow",ring_vm_math_pow);
  24         ring_vm_funcregister("sqrt",ring_vm_math_sqrt);
  25         ring_vm_funcregister("unsigned",ring_vm_math_unsigned);
  26         ring_vm_funcregister("decimals",ring_vm_math_decimals);
  27         ring_vm_funcregister("murmur3hash",ring_vm_math_murmur3hash);
  28 }
  29
  30 void ring_vm_math_sin ( void *pPointer )
  31 {
  32         if ( RING_API_PARACOUNT != 1 ) {
  33                 RING_API_ERROR(RING_API_MISS1PARA);
  34                 return ;
  35         }
  36         if ( RING_API_ISNUMBER(1) ) {
  37                 RING_API_RETNUMBER(sin(RING_API_GETNUMBER(1)));
  38         } else {
  39                 RING_API_ERROR(RING_API_BADPARATYPE);
  40         }
  41 }
  42
  43 void ring_vm_math_cos ( void *pPointer )
  44 {
  45         if ( RING_API_PARACOUNT != 1 ) {
  46                 RING_API_ERROR(RING_API_MISS1PARA);
  47                 return ;
  48         }
  49         if ( RING_API_ISNUMBER(1) ) {
  50                 RING_API_RETNUMBER(cos(RING_API_GETNUMBER(1)));
  51         } else {
  52                 RING_API_ERROR(RING_API_BADPARATYPE);
  53         }
  54 }
  55
  56 void ring_vm_math_tan ( void *pPointer )
  57 {
  58         if ( RING_API_PARACOUNT != 1 ) {
  59                 RING_API_ERROR(RING_API_MISS1PARA);
  60                 return ;
  61         }
  62         if ( RING_API_ISNUMBER(1) ) {
  63                 RING_API_RETNUMBER(tan(RING_API_GETNUMBER(1)));
  64         } else {
  65                 RING_API_ERROR(RING_API_BADPARATYPE);
  66         }
  67 }
  68
  69 void ring_vm_math_asin ( void *pPointer )
  70 {
  71         if ( RING_API_PARACOUNT != 1 ) {
  72                 RING_API_ERROR(RING_API_MISS1PARA);
  73                 return ;
  74         }
  75         if ( RING_API_ISNUMBER(1) ) {
  76                 RING_API_RETNUMBER(asin(RING_API_GETNUMBER(1)));
  77         } else {
  78                 RING_API_ERROR(RING_API_BADPARATYPE);
  79         }
  80 }
  81
  82 void ring_vm_math_acos ( void *pPointer )
  83 {
  84         if ( RING_API_PARACOUNT != 1 ) {
  85                 RING_API_ERROR(RING_API_MISS1PARA);
  86                 return ;
  87         }
  88         if ( RING_API_ISNUMBER(1) ) {
  89                 RING_API_RETNUMBER(acos(RING_API_GETNUMBER(1)));
  90         } else {
  91                 RING_API_ERROR(RING_API_BADPARATYPE);
  92         }
  93 }
  94
  95 void ring_vm_math_atan ( void *pPointer )
  96 {
  97         if ( RING_API_PARACOUNT != 1 ) {
  98                 RING_API_ERROR(RING_API_MISS1PARA);
  99                 return ;
 100         }
 101         if ( RING_API_ISNUMBER(1) ) {
 102                 RING_API_RETNUMBER(atan(RING_API_GETNUMBER(1)));
 103         } else {
 104                 RING_API_ERROR(RING_API_BADPARATYPE);
 105         }
 106 }
 107
 108 void ring_vm_math_atan2 ( void *pPointer )
 109 {
 110         if ( RING_API_PARACOUNT != 2 ) {
 111                 RING_API_ERROR(RING_API_MISS2PARA);
 112                 return ;
 113         }
 114         if ( RING_API_ISNUMBER(1) && RING_API_ISNUMBER(2) ) {
 115                 RING_API_RETNUMBER(atan2(RING_API_GETNUMBER(1),RING_API_GETNUMBER(2)));
 116         } else {
 117                 RING_API_ERROR(RING_API_BADPARATYPE);
 118         }
 119 }
 120
 121 void ring_vm_math_sinh ( void *pPointer )
 122 {
 123         if ( RING_API_PARACOUNT != 1 ) {
 124                 RING_API_ERROR(RING_API_MISS1PARA);
 125                 return ;
 126         }
 127         if ( RING_API_ISNUMBER(1) ) {
 128                 RING_API_RETNUMBER(sinh(RING_API_GETNUMBER(1)));
 129         } else {
 130                 RING_API_ERROR(RING_API_BADPARATYPE);
 131         }
 132 }
 133
 134 void ring_vm_math_cosh ( void *pPointer )
 135 {
 136         if ( RING_API_PARACOUNT != 1 ) {
 137                 RING_API_ERROR(RING_API_MISS1PARA);
 138                 return ;
 139         }
 140         if ( RING_API_ISNUMBER(1) ) {
 141                 RING_API_RETNUMBER(cosh(RING_API_GETNUMBER(1)));
 142         } else {
 143                 RING_API_ERROR(RING_API_BADPARATYPE);
 144         }
 145 }
 146
 147 void ring_vm_math_tanh ( void *pPointer )
 148 {
 149         if ( RING_API_PARACOUNT != 1 ) {
 150                 RING_API_ERROR(RING_API_MISS1PARA);
 151                 return ;
 152         }
 153         if ( RING_API_ISNUMBER(1) ) {
 154                 RING_API_RETNUMBER(tanh(RING_API_GETNUMBER(1)));
 155         } else {
 156                 RING_API_ERROR(RING_API_BADPARATYPE);
 157         }
 158 }
 159
 160 void ring_vm_math_exp ( void *pPointer )
 161 {
 162         if ( RING_API_PARACOUNT != 1 ) {
 163                 RING_API_ERROR(RING_API_MISS1PARA);
 164                 return ;
 165         }
 166         if ( RING_API_ISNUMBER(1) ) {
 167                 RING_API_RETNUMBER(exp(RING_API_GETNUMBER(1)));
 168         } else {
 169                 RING_API_ERROR(RING_API_BADPARATYPE);
 170         }
 171 }
 172
 173 void ring_vm_math_log ( void *pPointer )
 174 {
 175         if ( RING_API_PARACOUNT != 1 ) {
 176                 RING_API_ERROR(RING_API_MISS1PARA);
 177                 return ;
 178         }
 179         if ( RING_API_ISNUMBER(1) ) {
 180                 RING_API_RETNUMBER(log(RING_API_GETNUMBER(1)));
 181         } else {
 182                 RING_API_ERROR(RING_API_BADPARATYPE);
 183         }
 184 }
 185
 186 void ring_vm_math_log10 ( void *pPointer )
 187 {
 188         if ( RING_API_PARACOUNT != 1 ) {
 189                 RING_API_ERROR(RING_API_MISS1PARA);
 190                 return ;
 191         }
 192         if ( RING_API_ISNUMBER(1) ) {
 193                 RING_API_RETNUMBER(log10(RING_API_GETNUMBER(1)));
 194         } else {
 195                 RING_API_ERROR(RING_API_BADPARATYPE);
 196         }
 197 }
 198
 199 void ring_vm_math_ceil ( void *pPointer )
 200 {
 201         if ( RING_API_PARACOUNT != 1 ) {
 202                 RING_API_ERROR(RING_API_MISS1PARA);
 203                 return ;
 204         }
 205         if ( RING_API_ISNUMBER(1) ) {
 206                 RING_API_RETNUMBER(ceil(RING_API_GETNUMBER(1)));
 207         } else {
 208                 RING_API_ERROR(RING_API_BADPARATYPE);
 209         }
 210 }
 211
 212 void ring_vm_math_floor ( void *pPointer )
 213 {
 214         if ( RING_API_PARACOUNT != 1 ) {
 215                 RING_API_ERROR(RING_API_MISS1PARA);
 216                 return ;
 217         }
 218         if ( RING_API_ISNUMBER(1) ) {
 219                 RING_API_RETNUMBER(floor(RING_API_GETNUMBER(1)));
 220         } else {
 221                 RING_API_ERROR(RING_API_BADPARATYPE);
 222         }
 223 }
 224
 225 void ring_vm_math_fabs ( void *pPointer )
 226 {
 227         if ( RING_API_PARACOUNT != 1 ) {
 228                 RING_API_ERROR(RING_API_MISS1PARA);
 229                 return ;
 230         }
 231         if ( RING_API_ISNUMBER(1) ) {
 232                 RING_API_RETNUMBER(fabs(RING_API_GETNUMBER(1)));
 233         } else {
 234                 RING_API_ERROR(RING_API_BADPARATYPE);
 235         }
 236 }
 237
 238 void ring_vm_math_pow ( void *pPointer )
 239 {
 240         if ( RING_API_PARACOUNT != 2 ) {
 241                 RING_API_ERROR(RING_API_MISS2PARA);
 242                 return ;
 243         }
 244         if ( RING_API_ISNUMBER(1) && RING_API_ISNUMBER(2) ) {
 245                 RING_API_RETNUMBER(pow(RING_API_GETNUMBER(1),RING_API_GETNUMBER(2)));
 246         } else {
 247                 RING_API_ERROR(RING_API_BADPARATYPE);
 248         }
 249 }
 250
 251 void ring_vm_math_sqrt ( void *pPointer )
 252 {
 253         if ( RING_API_PARACOUNT != 1 ) {
 254                 RING_API_ERROR(RING_API_MISS1PARA);
 255                 return ;
 256         }
 257         if ( RING_API_ISNUMBER(1) ) {
 258                 RING_API_RETNUMBER(sqrt(RING_API_GETNUMBER(1)));
 259         } else {
 260                 RING_API_ERROR(RING_API_BADPARATYPE);
 261         }
 262 }
 263
 264 void ring_vm_math_unsigned ( void *pPointer )
 265 {
 266         unsigned long nNum1,nNum2,nNum3  ;
 267         const char *cStr  ;
 268         if ( RING_API_PARACOUNT != 3 ) {
 269                 RING_API_ERROR(RING_API_MISS3PARA);
 270                 return ;
 271         }
 272         if ( RING_API_ISNUMBER(1) && RING_API_ISNUMBER(2) && RING_API_ISSTRING(3) ) {
 273                 nNum1 = (unsigned long) RING_API_GETNUMBER(1) ;
 274                 nNum2 = (unsigned long) RING_API_GETNUMBER(2) ;
 275                 cStr = RING_API_GETSTRING(3) ;
 276                 if ( strcmp(cStr,">>") == 0 ) {
 277                         nNum3 = nNum1 >> nNum2 ;
 278                 }
 279                 else if ( strcmp(cStr,"<<") == 0 ) {
 280                         nNum3 = nNum1 << nNum2 ;
 281                 }
 282                 else if ( strcmp(cStr,"+") == 0 ) {
 283                         nNum3 = nNum1 + nNum2 ;
 284                 }
 285                 else if ( strcmp(cStr,"-") == 0 ) {
 286                         nNum3 = nNum1 - nNum2 ;
 287                 }
 288                 else if ( strcmp(cStr,"*") == 0 ) {
 289                         nNum3 = nNum1 * nNum2 ;
 290                 }
 291                 else if ( strcmp(cStr,"/") == 0 ) {
 292                         if ( nNum2 != 0 ) {
 293                                 nNum3 = nNum1 / nNum2 ;
 294                         }
 295                         else {
 296                                 RING_API_ERROR(RING_VM_ERROR_DIVIDEBYZERO);
 297                                 return ;
 298                         }
 299                 }
 300                 else if ( strcmp(cStr,"^") == 0 ) {
 301                         nNum3 = nNum1 ^ nNum2 ;
 302                 }
 303                 else if ( strcmp(cStr,"<") == 0 ) {
 304                         nNum3 = nNum1 < nNum2 ;
 305                 }
 306                 else if ( strcmp(cStr,">") == 0 ) {
 307                         nNum3 = nNum1 > nNum2 ;
 308                 }
 309                 else if ( strcmp(cStr,"<=") == 0 ) {
 310                         nNum3 = nNum1 <= nNum2 ;
 311                 }
 312                 else if ( strcmp(cStr,">=") == 0 ) {
 313                         nNum3 = nNum1 >= nNum2 ;
 314                 }
 315                 else if ( strcmp(cStr,"=") == 0 ) {
 316                         nNum3 = nNum1 == nNum2 ;
 317                 }
 318                 else if ( strcmp(cStr,"!=") == 0 ) {
 319                         nNum3 = nNum1 != nNum2 ;
 320                 }
 321                 else if ( strcmp(cStr,"&") == 0 ) {
 322                         nNum3 = nNum1 & nNum2 ;
 323                 }
 324                 else if ( strcmp(cStr,"|") == 0 ) {
 325                         nNum3 = nNum1 | nNum2 ;
 326                 }
 327                 else if ( strcmp(cStr,"~") == 0 ) {
 328                         nNum3 = ~ nNum1 ;
 329                 } else {
 330                         RING_API_ERROR(RING_API_BADPARATYPE);
 331                         return ;
 332                 }
 333                 RING_API_RETNUMBER((double) nNum3);
 334         } else {
 335                 RING_API_ERROR(RING_API_BADPARATYPE);
 336         }
 337 }
 338
 339 void ring_vm_math_decimals ( void *pPointer )
 340 {
 341         int nNum1  ;
 342         if ( RING_API_PARACOUNT == 1 ) {
 343                 if ( RING_API_ISNUMBER(1) ) {
 344                         nNum1 = (int) RING_API_GETNUMBER(1) ;
 345                         if ( (nNum1 >= 0) && (nNum1 <= 14) ) {
 346                                 ((VM *) pPointer)->nDecimals = nNum1 ;
 347                         }
 348                         else {
 349                                 RING_API_ERROR(RING_VM_ERROR_BADDECIMALNUMBER);
 350                         }
 351                 } else {
 352                         RING_API_ERROR(RING_API_BADPARATYPE);
 353                 }
 354         } else {
 355                 RING_API_ERROR(RING_API_BADPARACOUNT);
 356         }
 357 }
 358 /* Hash */
 359
 360 void ring_vm_math_murmur3hash ( void *pPointer )
 361 {
 362         unsigned int nResult  ;
 363         if ( RING_API_PARACOUNT != 2 ) {
 364                 RING_API_ERROR(RING_API_MISS2PARA);
 365                 return ;
 366         }
 367         if ( RING_API_ISSTRING(1) && RING_API_ISNUMBER(2) ) {
 368                 nResult = ring_murmur3_32(RING_API_GETSTRING(1),RING_API_GETSTRINGSIZE(1),RING_API_GETNUMBER(2));
 369                 RING_API_RETNUMBER(nResult);
 370         } else {
 371                 RING_API_ERROR(RING_API_BADPARATYPE);
 372         }
 373 }