@agoric/xsnap 0.14.3-u14.0 → 0.14.3-u16.1

package/moddable/xs/sources/xsMath.c

@@ -0,0 +1,624 @@
+/*
+ * Copyright (c) 2016-2017  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"
+
+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);
+	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);
+	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);
+	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
+		_BitScanForward(&r, x);
+#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)
+{
+	txInteger x = (mxArgc > 0) ? fxToInteger(the, mxArgv(0)) : 0;
+	txInteger y = (mxArgc > 1) ? fxToInteger(the, mxArgv(1)) : 0;
+	if (y == 0) {
+		mxPushNumber(C_NAN);
+		mxPushNumber(C_NAN);
+	}
+	else {
+#if mxIntegerDivideOverflowException
+		if ((x == (txInteger)0x80000000) && (y == -1)) {
+			mxPushInteger(x);
+			mxPushInteger(0);
+		}
+		else
+#endif
+		{
+			mxPushInteger(x / y);
+			mxPushInteger((x % y + y) % y);
+		}
+	}
+	fxConstructArrayEntry(the, mxResult);
+}
+
+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;
+		if ((-2147483648LL <= r) && (r <= 2147483647LL)) {
+			mxResult->kind = XS_INTEGER_KIND;
+			mxResult->value.integer = (txInteger)r;
+		}
+		else {
+			mxResult->kind = XS_NUMBER_KIND;
+			mxResult->value.number = (txNumber)r;
+		}
+	}
+}
+
+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;
+	mxResult->kind = XS_NUMBER_KIND;
+	mxResult->value.number = -((txNumber)C_INFINITY);
+	for (i = 0; i < c; i++) {
+		txNumber n = fxToNumber(the, mxArgv(i));
+		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;
+	mxResult->kind = XS_NUMBER_KIND;
+	mxResult->value.number = (txNumber)C_INFINITY;
+	for (i = 0; i < c; i++) {
+		txNumber n = fxToNumber(the, mxArgv(i));
+		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 = c_rand();
+	while (result == C_RAND_MAX)
+		result = c_rand();
+	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_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;
+	}
+}