/*

 * Copyright (c) 2016-2025  Moddable Tech, Inc.

 *

 *   This file is part of the Moddable SDK Runtime.

 * 

 *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify

 *   it under the terms of the GNU Lesser General Public License as published by

 *   the Free Software Foundation, either version 3 of the License, or

 *   (at your option) any later version.

 * 

 *   The Moddable SDK Runtime is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU Lesser General Public License for more details.

 * 

 *   You should have received a copy of the GNU Lesser General Public License

 *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.

 *

 * This file incorporates work covered by the following copyright and  

 * permission notice:  

 *

 *       Copyright (C) 2010-2016 Marvell International Ltd.

 *       Copyright (C) 2002-2010 Kinoma, Inc.

 *

 *       Licensed under the Apache License, Version 2.0 (the "License");

 *       you may not use this file except in compliance with the License.

 *       You may obtain a copy of the License at

 *

 *        http://www.apache.org/licenses/LICENSE-2.0

 *

 *       Unless required by applicable law or agreed to in writing, software

 *       distributed under the License is distributed on an "AS IS" BASIS,

 *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *       See the License for the specific language governing permissions and

 *       limitations under the License.

 */

#include "xsAll.h"

#include "xsum.c"

void fxBuildMath(txMachine* the)

{

  txSlot* slot;

  mxPush(mxObjectPrototype);

  slot = fxLastProperty(the, fxNewObjectInstance(the));

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_abs), 1, mxID(_abs), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_acos), 1, mxID(_acos), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_acosh), 1, mxID(_acosh), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_asin), 1, mxID(_asin), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_asinh), 1, mxID(_asinh), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_atan), 1, mxID(_atan), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_atanh), 1, mxID(_atanh), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_atan2), 2, mxID(_atan2), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_cbrt), 1, mxID(_cbrt), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_ceil), 1, mxID(_ceil), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_clz32), 1, mxID(_clz32), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_cos), 1, mxID(_cos), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_cosh), 1, mxID(_cosh), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_exp), 1, mxID(_exp), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_expm1), 1, mxID(_expm1), XS_DONT_ENUM_FLAG);

#if mxFloat16

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_f16round), 1, mxID(_f16round), XS_DONT_ENUM_FLAG);

#endif

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_floor), 1, mxID(_floor), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_fround), 1, mxID(_fround), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_hypot), 2, mxID(_hypot_), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_idiv), 2, mxID(_idiv), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_idivmod), 2, mxID(_idivmod), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_imod), 2, mxID(_imod), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_imul), 2, mxID(_imul), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_imuldiv), 2, mxID(_imuldiv), XS_DONT_ENUM_FLAG);

#if mxECMAScript2023

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_irandom), 0, mxID(_irandom), XS_DONT_ENUM_FLAG);

#endif

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_irem), 2, mxID(_irem), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_log), 1, mxID(_log), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_log1p), 1, mxID(_log1p), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_log10), 1, mxID(_log10), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_log2), 1, mxID(_log2), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_max), 2, mxID(_max), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_min), 2, mxID(_min), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_mod), 2, mxID(_mod), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_pow), 2, mxID(_pow), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_random), 0, mxID(_random), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_round), 1, mxID(_round), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_sign), 1, mxID(_sign), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_sin), 1, mxID(_sin), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_sinh), 1, mxID(_sinh), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_sqrt), 1, mxID(_sqrt), XS_DONT_ENUM_FLAG);

#if mxECMAScript2026

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_sumPrecise), 1, mxID(_sumPrecise), XS_DONT_ENUM_FLAG);

#endif

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_tan), 1, mxID(_tan), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_tanh), 1, mxID(_tanh), XS_DONT_ENUM_FLAG);

  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Math_trunc), 1, mxID(_trunc), XS_DONT_ENUM_FLAG);

  slot = fxNextNumberProperty(the, slot, C_M_E, mxID(_E), XS_GET_ONLY);

  slot = fxNextNumberProperty(the, slot, C_M_LN10, mxID(_LN10), XS_GET_ONLY);

  slot = fxNextNumberProperty(the, slot, C_M_LN2, mxID(_LN2), XS_GET_ONLY);

  slot = fxNextNumberProperty(the, slot, C_M_LOG10E, mxID(_LOG10E), XS_GET_ONLY);

  slot = fxNextNumberProperty(the, slot, C_M_LOG2E, mxID(_LOG2E), XS_GET_ONLY);

  slot = fxNextNumberProperty(the, slot, C_M_PI, mxID(_PI), XS_GET_ONLY);

  slot = fxNextNumberProperty(the, slot, C_M_SQRT1_2, mxID(_SQRT1_2), XS_GET_ONLY);

  slot = fxNextNumberProperty(the, slot, C_M_SQRT2, mxID(_SQRT2), XS_GET_ONLY);

  slot = fxNextStringXProperty(the, slot, "Math", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);

  mxPull(mxMathObject);

//@@  c_srand((unsigned)c_time(0));

}

#define mxNanResultIfNoArg \

  if (mxArgc < 1) {  \

    mxResult->kind = XS_NUMBER_KIND; \

    mxResult->value.number = C_NAN; \

    return; \

  }

#define mxNanResultIfNoArg2 \

  if (mxArgc < 2) {  \

    mxResult->kind = XS_NUMBER_KIND; \

    mxResult->value.number = C_NAN; \

    return; \

  }

void fx_Math_abs(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_fabs(mxArgv(0)->value.number);

}

void fx_Math_acos(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_acos(mxArgv(0)->value.number);

}

void fx_Math_acosh(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_acosh(mxArgv(0)->value.number);

}

void fx_Math_asin(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_asin(mxArgv(0)->value.number);

}

void fx_Math_asinh(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_asinh(mxArgv(0)->value.number);

}

void fx_Math_atan(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_atan(mxArgv(0)->value.number);

}

void fx_Math_atanh(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_atanh(mxArgv(0)->value.number);

}

void fx_Math_atan2(txMachine* the)

{

  mxNanResultIfNoArg2;

  fxToNumber(the, mxArgv(0));

  fxToNumber(the, mxArgv(1));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_atan2(mxArgv(0)->value.number, mxArgv(1)->value.number);

}

void fx_Math_cbrt(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_cbrt(mxArgv(0)->value.number);

}

void fx_Math_ceil(txMachine* the)

{

  mxNanResultIfNoArg;

  if (XS_INTEGER_KIND == mxArgv(0)->kind) {

    mxResult->kind = XS_INTEGER_KIND;

    mxResult->value.integer = mxArgv(0)->value.integer;

    return;

  }

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_ceil(mxArgv(0)->value.number);

  fx_Math_toInteger(the);

}

void fx_Math_clz32(txMachine* the)

{

  txUnsigned x = (mxArgc > 0) ? fxToUnsigned(the, mxArgv(0)) : 0;

  txInteger r;

  if (x)

#if mxWindows

  {

    _BitScanReverse(&r, x);

    r = 31 - r;

  }

#else

    r = __builtin_clz(x);

#endif  

  else

    r = 32;

  mxResult->kind = XS_INTEGER_KIND;

  mxResult->value.integer = r;

}

void fx_Math_cos(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_cos(mxArgv(0)->value.number);

}

void fx_Math_cosh(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_cosh(mxArgv(0)->value.number);

}

void fx_Math_exp(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_exp(mxArgv(0)->value.number);

}

void fx_Math_expm1(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_expm1(mxArgv(0)->value.number);

}

void fx_Math_floor(txMachine* the)

{

  mxNanResultIfNoArg;

  if (XS_INTEGER_KIND == mxArgv(0)->kind) {

    mxResult->kind = XS_INTEGER_KIND;

    mxResult->value.integer = mxArgv(0)->value.integer;

    return;

  }

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_floor(mxArgv(0)->value.number);

  fx_Math_toInteger(the);

}

void fx_Math_fround(txMachine* the)

{

  float arg;

  mxNanResultIfNoArg;

  if (XS_INTEGER_KIND == mxArgv(0)->kind) {

    mxResult->kind = XS_INTEGER_KIND;

    mxResult->value.integer = mxArgv(0)->value.integer;

    return;

  }

  arg = (float)fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = arg;

}

void fx_Math_hypot(txMachine* the)

{

  if (mxArgc == 2) {

    fxToNumber(the, mxArgv(0));

    fxToNumber(the, mxArgv(1));

    mxResult->kind = XS_NUMBER_KIND;

    mxResult->value.number = c_hypot(mxArgv(0)->value.number, mxArgv(1)->value.number);

  }

  else {

    txInteger c = mxArgc, i;

    txNumber result = 0;

    for (i = 0; i < c; i++) {

      txNumber argument = fxToNumber(the, mxArgv(i));

      result += argument * argument;

    }

    mxResult->kind = XS_NUMBER_KIND;

    mxResult->value.number = c_sqrt(result);

  }

}

void fx_Math_idiv(txMachine* the)

{

  txInteger x = (mxArgc > 0) ? fxToInteger(the, mxArgv(0)) : 0;

  txInteger y = (mxArgc > 1) ? fxToInteger(the, mxArgv(1)) : 0;

  if (y == 0) {

    mxResult->kind = XS_NUMBER_KIND;

    mxResult->value.number = C_NAN;

  }

  else {

    mxResult->kind = XS_INTEGER_KIND;

#if mxIntegerDivideOverflowException

    if ((x == (txInteger)0x80000000) && (y == -1))

      mxResult->value.integer = x;

    else

#endif

      mxResult->value.integer = x / y;

  }

}

void fx_Math_idivmod(txMachine* the)

{

  mxTypeError("not available");

}

void fx_Math_imod(txMachine* the)

{

  txInteger x = (mxArgc > 0) ? fxToInteger(the, mxArgv(0)) : 0;

  txInteger y = (mxArgc > 1) ? fxToInteger(the, mxArgv(1)) : 0;

  if (y == 0) {

    mxResult->kind = XS_NUMBER_KIND;

    mxResult->value.number = C_NAN;

  }

  else {

    mxResult->kind = XS_INTEGER_KIND;

#if mxIntegerDivideOverflowException

    if ((x == (txInteger)0x80000000) && (y == -1))

      mxResult->value.integer = 0;

    else

#endif

      mxResult->value.integer = (x % y + y) % y;

  }

}

void fx_Math_imul(txMachine* the)

{

  txInteger x = (mxArgc > 0) ? fxToInteger(the, mxArgv(0)) : 0;

  txInteger y = (mxArgc > 1) ? fxToInteger(the, mxArgv(1)) : 0;

  mxResult->kind = XS_INTEGER_KIND;

  mxResult->value.integer = x * y;

}

void fx_Math_imuldiv(txMachine* the)

{

  txS8 x = (mxArgc > 0) ? fxToInteger(the, mxArgv(0)) : 0;

  txS8 y = (mxArgc > 1) ? fxToInteger(the, mxArgv(1)) : 0;

  txS8 z = (mxArgc > 2) ? fxToInteger(the, mxArgv(2)) : 0;

  if (z == 0) {

    mxResult->kind = XS_NUMBER_KIND;

    mxResult->value.number = C_NAN;

  }

  else {

    txS8 r = (x * y) / z;

    mxResult->kind = XS_INTEGER_KIND;

    mxResult->value.integer = (txInteger)(r & 0x00000000FFFFFFFF);

  }

}

void fx_Math_irandom(txMachine* the)

{

  double min = 0;

  double max = 2147483647;

  uint32_t result;

  if (mxArgc > 1) {

    min = (double)fxToInteger(the, mxArgv(0));

    max = (double)fxToInteger(the, mxArgv(1));

  }

  else if (mxArgc > 0) {

    max = (double)fxToInteger(the, mxArgv(0));

  }

  result = c_rand();

  while (result == C_RAND_MAX)

    result = c_rand();

  if (max < min)

    mxResult->value.integer = (txInteger)c_ceil(min + (((double)result / (double)C_RAND_MAX) * (max - min)));

  else

    mxResult->value.integer = (txInteger)c_floor(min + (((double)result / (double)C_RAND_MAX) * (max - min)));

  mxResult->kind = XS_INTEGER_KIND;

}

void fx_Math_irandom_secure(txMachine* the)

{

  mxTypeError("secure mode");

}

void fx_Math_irem(txMachine* the)

{

  txInteger x = (mxArgc > 0) ? fxToInteger(the, mxArgv(0)) : 0;

  txInteger y = (mxArgc > 1) ? fxToInteger(the, mxArgv(1)) : 0;

  if (y == 0) {

    mxResult->kind = XS_NUMBER_KIND;

    mxResult->value.number = C_NAN;

  }

  else {

    mxResult->kind = XS_INTEGER_KIND;

#if mxIntegerDivideOverflowException

    if ((x == (txInteger)0x80000000) && (y == -1))

      mxResult->value.integer = 0;

    else

#endif

      mxResult->value.integer = x % y;

  }

}

void fx_Math_log(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_log(mxArgv(0)->value.number);

}

void fx_Math_log1p(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_log1p(mxArgv(0)->value.number);

}

void fx_Math_log10(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_log10(mxArgv(0)->value.number);

}

void fx_Math_log2(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

#if mxAndroid

  mxResult->value.number = c_log(mxArgv(0)->value.number) / c_log(2);

#else

  mxResult->value.number = c_log2(mxArgv(0)->value.number);

#endif

}

void fx_Math_max(txMachine* the)

{

  txInteger c = mxArgc, i = 0;

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = -((txNumber)C_INFINITY);

  if (0 == c)

    return;

  if (XS_INTEGER_KIND == mxArgv(0)->kind) {

    mxResult->kind = XS_INTEGER_KIND;

    mxResult->value.integer = mxArgv(0)->value.integer;

    i = 1;

  }

  for (; i < c; i++) {

    txSlot *slot = mxArgv(i);

    if (XS_INTEGER_KIND == mxResult->kind) {

      if (XS_INTEGER_KIND == slot->kind) {

        if (mxResult->value.integer < slot->value.integer) {

          mxResult->value.integer = slot->value.integer;

        }

        continue;

      }

      mxResult->kind = XS_NUMBER_KIND;

      mxResult->value.number = mxResult->value.integer;

    }

    txNumber n = fxToNumber(the, slot);

    if (c_isnan(n)) {

      for (; i < c; i++)

        fxToNumber(the, mxArgv(i));

      mxResult->value.number = C_NAN;

      return;

    }

    if (mxResult->value.number < n)

      mxResult->value.number = n;

    else if ((mxResult->value.number == 0) && (n == 0)) {

      if (c_signbit(mxResult->value.number) != c_signbit(n))

        mxResult->value.number = 0;

    }

  }

}

void fx_Math_min(txMachine* the)

{

  txInteger c = mxArgc, i = 0;

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = (txNumber)C_INFINITY;

  if (0 == c)

    return;

  if (XS_INTEGER_KIND == mxArgv(0)->kind) {

    mxResult->kind = XS_INTEGER_KIND;

    mxResult->value.integer = mxArgv(0)->value.integer;

    i = 1;

  }

  for (; i < c; i++) {

    txSlot *slot = mxArgv(i);

    if (XS_INTEGER_KIND == mxResult->kind) {

      if (XS_INTEGER_KIND == slot->kind) {

        if (mxResult->value.integer > slot->value.integer)

          mxResult->value.integer = slot->value.integer;

        continue;

      }

      mxResult->kind = XS_NUMBER_KIND;

      mxResult->value.number = mxResult->value.integer;

    }

    txNumber n = fxToNumber(the, slot);

    if (c_isnan(n)) {

      for (; i < c; i++)

        fxToNumber(the, mxArgv(i));

      mxResult->value.number = C_NAN;

      return;

    }

    if (mxResult->value.number > n)

      mxResult->value.number = n;

    else if ((mxResult->value.number == 0) && (n == 0)) {

      if (c_signbit(mxResult->value.number) != c_signbit(n))

        mxResult->value.number = -0.0;

    }

  }

}

void fx_Math_mod(txMachine* the)

{

  txNumber x = (mxArgc > 0) ? fxToNumber(the, mxArgv(0)) : 0;

  txNumber y = (mxArgc > 1) ? fxToNumber(the, mxArgv(1)) : 0;

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_fmod((c_fmod(x, y) + y), y);

}

txNumber fx_pow(txNumber x, txNumber y)

{

  if (!c_isfinite(y) && (c_fabs(x) == 1.0))

    return C_NAN;

  return c_pow(x, y);

}

void fx_Math_pow(txMachine* the)

{

  txNumber x, y;

  mxNanResultIfNoArg2;

  x = fxToNumber(the, mxArgv(0));

  y = fxToNumber(the, mxArgv(1));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = fx_pow(x, y);

}

void fx_Math_random(txMachine* the)

{

  uint32_t result;

  do {

    result = c_rand();

  } while (result == C_RAND_MAX);

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = (double)result / (double)C_RAND_MAX;

}

void fx_Math_random_secure(txMachine* the)

{

  mxTypeError("secure mode");

}

void fx_Math_round(txMachine* the)

{

    txNumber arg;

  mxNanResultIfNoArg;

  if (XS_INTEGER_KIND == mxArgv(0)->kind) {

    mxResult->kind = XS_INTEGER_KIND;

    mxResult->value.integer = mxArgv(0)->value.integer;

    return;

  }

  arg = fxToNumber(the, mxArgv(0));

  if (c_isnormal(arg) && (-4503599627370495 < arg) && (arg < 4503599627370495)) { // 2 ** 52 - 1

    if ((arg < -0.5) || (0.5 <= arg))

      arg = c_floor(arg + 0.5);

    else if (arg < 0)

      arg = -0.0;

    else if (arg > 0)

      arg = 0.0;

    }

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = arg;

  fx_Math_toInteger(the);

}

void fx_Math_sqrt(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_sqrt(mxArgv(0)->value.number);

}

void fx_Math_sumPrecise(txMachine* the)

{

  txSlot *iterable, *iterator, *next, *value;

  xsum_small_accumulator accumulator;

  txInteger count = 0;

  txBoolean flag = 1;

  if (mxArgc < 1)

    mxTypeError("no items");

  iterable = mxArgv(0);

  fxToInstance(the, iterable);

  mxTemporary(iterator);

  mxTemporary(next);

  fxGetIterator(the, iterable, iterator, next, 0);  

  xsum_small_init(&accumulator);

  mxTemporary(value);

  while (fxIteratorNext(the, iterator, next, value)) {

    mxTry(the) {

      if (value->kind == XS_INTEGER_KIND) {

        flag = 0;

        xsum_small_add1(&accumulator, value->value.integer);

      }

      else if (value->kind == XS_NUMBER_KIND) {

        if (value->value.number != -0.0) {

          flag = 0;

          xsum_small_add1(&accumulator, value->value.number);

        }

      }

      else

        mxTypeError("items[%d]: not a number", count);

      count++;

    }

    mxCatch(the) {

      fxIteratorReturn(the, iterator, 1);

      fxJump(the);

    }

  }

  if (flag)

    mxResult->value.number = -0.0;

  else

    mxResult->value.number = xsum_small_round(&accumulator);

  mxResult->kind = XS_NUMBER_KIND;

}

void fx_Math_sign(txMachine* the)

{

  txNumber arg;

  mxNanResultIfNoArg;

  arg = fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  if (c_isnan(arg))

    mxResult->value.number = C_NAN;

  else if (arg < 0)

    mxResult->value.number = -1;

  else if (arg > 0)

    mxResult->value.number = 1;

  else

    mxResult->value.number = arg;

  fx_Math_toInteger(the);

}

void fx_Math_sin(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_sin(mxArgv(0)->value.number);

}

void fx_Math_sinh(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_sinh(mxArgv(0)->value.number);

}

void fx_Math_tan(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_tan(mxArgv(0)->value.number);

}

void fx_Math_tanh(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_tanh(mxArgv(0)->value.number);

}

void fx_Math_trunc(txMachine* the)

{

  mxNanResultIfNoArg;

  fxToNumber(the, mxArgv(0));

  mxResult->kind = XS_NUMBER_KIND;

  mxResult->value.number = c_trunc(mxArgv(0)->value.number);

  fx_Math_toInteger(the);

}

void fx_Math_toInteger(txMachine* the)

{

  txNumber number = mxResult->value.number;

  txInteger integer = (txInteger)number;

  txNumber check = integer;

  if ((number == check) && (number || !c_signbit(number))) {

    mxResult->value.integer = integer;

    mxResult->kind = XS_INTEGER_KIND;

  }

}