TinyJS_MathFunctions.cpp

/*
 * TinyJS
 *
 * A single-file Javascript-alike engine
 *
 * -  Math and Trigonometry functions
 *
 * Authored By O.Z.L.B. <ozlbinfo@gmail.com>
 *
 * Copyright (C) 2011 O.Z.L.B.
 *

 * 42TinyJS
 *
 * A fork of TinyJS with the goal to makes a more JavaScript/ECMA compliant engine
 *
 * Authored / Changed By Armin Diedering <armin@diedering.de>
 *
 * Copyright (C) 2010-2025 ardisoft
 *
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is furnished to do
 * so, subject to the following conditions:

 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <cmath>
#include <cstdlib>
#include <sstream>
#include <ctime>
#include "TinyJS.h"

namespace TinyJS {

inline constexpr double k_PI		= 3.1415926535897932384626433832795;  // π
inline constexpr double k_E			= 2.7182818284590452353602874713527;  // exp(1.0)
inline constexpr double k_LN2		= 0.69314718055994530941723212145818; // log(2.0)
inline constexpr double k_LN10		= 2.3025850929940456840179914546844;  // log(10.0)
inline constexpr double k_LOG2E		= 1.4426950408889634073599246810019;  // log(E) / log(2.0)
inline constexpr double k_LOG10E	= 0.43429448190325182765112891891661; // log10(E)
inline constexpr double k_SQRT1_2	= 0.70710678118654752440084436210485; // sqrt(0.5)
inline constexpr double k_SQRT2		= 1.4142135623730950488016887242097;  // sqrt(2.0)
/*
#define F_ABS(a)            ((a)>=0 ? (a) : (-(a)))
#define F_MIN(a,b)          ((a)>(b) ? (b) : (a))
#define F_MAX(a,b)          ((a)>(b) ? (a) : (b))
#define F_SGN(a)            ((a)>0 ? 1 : ((a)<0 ? -1 : 0 ))
#define F_RNG(a,min,max)    ((a)<(min) ? min : ((a)>(max) ? max : a ))
 */
#if defined(_MSC_VER) && _MSC_VER <= 1700
namespace
{

	double asinh( const double &value ) {
		double returned;

		if(value>0)
			returned = log(value + sqrt(value * value + 1));
		else
			returned = -log(-value + sqrt(value * value + 1));

		return(returned);
	}

	double acosh( const double &value ) {
		double returned;

		if(value>0)
			returned = log(value + sqrt(value * value - 1));
		 else
			returned = -log(-value + sqrt(value * value - 1));

		return(returned);
	}

	 double atanh( double value ) {
		bool neg = value<0;
		if(neg) value=-value;
		double value_x2 = 2.0*value;
		if(value>=0.5)
			value = log(1.0+value_x2/(1.0-value))/2.0;
		 else
			value = log(1.0+value_x2+value_x2*value/(1.0-value))/2.0;
		return(neg ? -value : value);
	}
}
#endif

#define PARAMETER_TO_NUMBER(v,n) CNumber v = c->getArgument(n)->toNumber()
#define RETURN_NAN_IS_NAN(v) do{ if(v.isNaN()) { c->setReturnVar(c->constScriptVar(NaN)); return; } }while(0)
#define RETURN_NAN_IS_NAN_OR_INFINITY(v) do{ if(v.isNaN() || v.isInfinity()) { c->setReturnVar(c->constScriptVar(NaN)); return; } }while(0)
#define RETURN_INFINITY_IS_INFINITY(v) do{ if(v.isInfinity()) { c->setReturnVar(c->constScriptVar(v.isInfinity()<0 ? InfinityNegative : InfinityPositive)); return; } }while(0)
#define RETURN_ZERO_IS_ZERO(v) do{ if(v.isZero()) { c->setReturnVar(c->newScriptVar(v)); return; } }while(0)
#define RETURN(a)	do{ c->setReturnVar(c->newScriptVar(a)); return; }while(0)
#define RETURNconst(a)	c->setReturnVar(c->constScriptVar(a))

//Math.abs(x) - returns absolute of given value
static void scMathAbs(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); 
	RETURN(a.sign()<0?-a:a);
}

//Math.round(a) - returns nearest round of given value
static void scMathRound(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a");
	RETURN(a.round());
}

//Math.ceil(a) - returns nearest round of given value
static void scMathCeil(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); RETURN_INFINITY_IS_INFINITY(a);
	RETURN(a.ceil());
}

//Math.floor(a) - returns nearest round of given value
static void scMathFloor(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); 
	RETURN(a.floor());
}

//Math.min(a,b) - returns minimum of two given values 
static void scMathMin(const CFunctionsScopePtr &c, void *userdata) {
	int length = c->getArgumentsLength();
	CNumber ret(InfinityPositive);
	for(int i=0; i<length; i++)
	{
		PARAMETER_TO_NUMBER(a,i); RETURN_NAN_IS_NAN(a);
		if(ret>a) ret=a;
	}
	RETURN(ret);
}

//Math.max(a,b) - returns maximum of two given values  
static void scMathMax(const CFunctionsScopePtr &c, void *userdata) {
	int length = c->getArgumentsLength();
	CNumber ret(InfinityNegative);
	for(int i=0; i<length; i++)
	{
		PARAMETER_TO_NUMBER(a,i); RETURN_NAN_IS_NAN(a);
		if(ret<a) ret=a;
	}
	RETURN(ret);
}

//Math.range(x,a,b) - returns value limited between two given values  
static void scMathRange(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(x,"x"); RETURN_NAN_IS_NAN(x); 
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	PARAMETER_TO_NUMBER(b,"b"); RETURN_NAN_IS_NAN(b);

	if(a>b) RETURNconst(NaN);
	if(x<a) RETURN(a);
	if(x>b) RETURN(b);
	RETURN(x);	
}

//Math.sign(a) - returns sign of given value (-1==negative,0=zero,1=positive)
static void scMathSign(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	RETURN(a.isZero() ? 0 : a.sign());
}
static void scMathRandom(const CFunctionsScopePtr &c, void *) {
	static int inited=0;
	if(!inited) {
		inited = 1;
		srand((unsigned int)time(NULL));
	}
	RETURN(double(rand())/RAND_MAX);
}

//Math.toDegrees(a) - returns degree value of a given angle in radians
static void scMathToDegrees(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); RETURN_INFINITY_IS_INFINITY(a); 
	RETURN( (180.0/k_PI)*a );
}

//Math.toRadians(a) - returns radians value of a given angle in degrees
static void scMathToRadians(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); RETURN_INFINITY_IS_INFINITY(a); 
	RETURN( (k_PI/180.0)*a );
}

//Math.sin(a) - returns trig. sine of given angle in radians
static void scMathSin(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN_OR_INFINITY(a); RETURN_ZERO_IS_ZERO(a);
	RETURN( sin(a.toDouble()) );
}

//Math.asin(a) - returns trig. arcsine of given angle in radians
static void scMathASin(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); RETURN_ZERO_IS_ZERO(a);
	if(abs(a)>1) RETURNconst(NaN);
	RETURN( asin(a.toDouble()) );
}

//Math.cos(a) - returns trig. cosine of given angle in radians
static void scMathCos(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN_OR_INFINITY(a); 
	if(a.isZero()) RETURN(1);
	RETURN( cos(a.toDouble()) );
}

//Math.acos(a) - returns trig. arccosine of given angle in radians
static void scMathACos(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN_OR_INFINITY(a); 
	if(abs(a)>1) RETURNconst(NaN);
	else if(a==1) RETURN(0);
	RETURN( acos(a.toDouble()) );
}

//Math.tan(a) - returns trig. tangent of given angle in radians
static void scMathTan(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN_OR_INFINITY(a); RETURN_ZERO_IS_ZERO(a);
	RETURN( tan(a.toDouble()) );
}

//Math.atan(a) - returns trig. arctangent of given angle in radians
static void scMathATan(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); RETURN_ZERO_IS_ZERO(a);
	int infinity=a.isInfinity();
	if(infinity) RETURN(k_PI/(infinity*2));
	RETURN( atan(a.toDouble()) );
}

//Math.atan2(a,b) - returns trig. arctangent of given angle in radians
static void scMathATan2(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a);
	PARAMETER_TO_NUMBER(b,"b"); RETURN_NAN_IS_NAN(b);
	int sign_a = a.sign();
	int sign_b = b.sign();
	if(a.isZero())
		RETURN(sign_a>0 ? (sign_b>0 ? 0.0 : k_PI) : (sign_b>0 ? -0.0 : -k_PI));
	else if(b.isZero())
		RETURN((sign_a>0 ? k_PI : -k_PI)/2.0);
	int infinity_a=a.isInfinity();
	int infinity_b=b.isInfinity();
	if(infinity_a) {
		if(infinity_b>0) RETURN(k_PI/(infinity_a*4)); 
		else if(infinity_b<0) RETURN(3.0*k_PI/(infinity_a*4));
		else RETURN(k_PI/(infinity_a*2));
	} else if(infinity_b>0)
		RETURN(sign_a>0 ? 0.0 : -0.0);
	else if(infinity_b<0)
		RETURN(sign_a>0 ? k_PI : -k_PI);
	RETURN( atan2(a.toDouble(), b.toDouble()) );
}


//Math.sinh(a) - returns trig. hyperbolic sine of given angle in radians
static void scMathSinh(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	RETURN_ZERO_IS_ZERO(a);
	if(abs(a)>1) RETURNconst(NaN);
	RETURN( sinh(a.toDouble()) );
}

//Math.asinh(a) - returns trig. hyperbolic arcsine of given angle in radians
static void scMathASinh(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	RETURN_INFINITY_IS_INFINITY(a);
	RETURN_ZERO_IS_ZERO(a);
	RETURN( asinh(a.toDouble()) );
}

//Math.cosh(a) - returns trig. hyperbolic cosine of given angle in radians
static void scMathCosh(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	if(a.isInfinity()) RETURNconst(InfinityPositive);
	RETURN( cosh(a.toDouble()) );
}

//Math.acosh(a) - returns trig. hyperbolic arccosine of given angle in radians
static void scMathACosh(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	RETURN_INFINITY_IS_INFINITY(a);
	if(abs(a)<1) RETURNconst(NaN);
	RETURN( acosh(a.toDouble()) );
}

//Math.tanh(a) - returns trig. hyperbolic tangent of given angle in radians
static void scMathTanh(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	RETURN_ZERO_IS_ZERO(a);
	if(a.isInfinity()) RETURN(a.sign());
	RETURN( tanh(a.toDouble()) );
}

//Math.atanh(a) - returns trig. hyperbolic arctangent of given angle in radians
static void scMathATanh(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	RETURN_ZERO_IS_ZERO(a);
	CNumber abs_a = abs(a);
	if(abs_a > 1) RETURNconst(NaN);
	if(abs_a == 1) RETURNconst(Infinity(a.sign()));
	RETURN( atanh(a.toDouble()) );
}

//Math.log(a) - returns natural logaritm (base E) of given value
static void scMathLog(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	if(a.isZero()) RETURNconst(InfinityNegative);
	if(a.sign()<0) RETURNconst(NaN);
	if(a.isInfinity()) RETURNconst(InfinityPositive);
	RETURN( log( a.toDouble()) );
}

//Math.log10(a) - returns logaritm(base 10) of given value
static void scMathLog10(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	if(a.isZero()) RETURNconst(InfinityNegative);
	if(a.sign()<0) RETURNconst(NaN);
	if(a.isInfinity()) RETURNconst(InfinityPositive);
	RETURN( log10( a.toDouble()) );
}

//Math.exp(a) - returns e raised to the power of a given number
static void scMathExp(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a);
	if(a.isZero()) RETURN(1);
	int a_i = a.isInfinity();
	if(a_i>0) RETURNconst(InfinityPositive);
	else if(a_i<0) RETURN(0);
	RETURN( exp(a.toDouble()) );
}

//Math.pow(a,b) - returns the result of a number raised to a power (a)^(b)
static void scMathPow(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a");
	PARAMETER_TO_NUMBER(b,"b"); 
	CNumber ret = a.pow(b);
	RETURN_NAN_IS_NAN(ret);
	RETURN_INFINITY_IS_INFINITY(ret);
	RETURN(ret);
/*
	RETURN_NAN_IS_NAN(b); 
	if(b.isZero()) RETURN(1);
	RETURN_NAN_IS_NAN(a);
	if(b==1) RETURN(a);

	int sign;
	CNumber a_abs = abs(a);
	if((sign = b.isInfinity())) {
		if( a_abs==1 ) RETURNconst(NaN);
		else if( (a_abs>1) ^ (sign<0) )	RETURN(b); else RETURN(0);
	} else if((sign = a.isInfinity())) {
		if(sign>0) {
			if(b.sign()>0) RETURN(a); else RETURN(0);
		} else {
			bool b_is_odd_int = ((b+1)/2).isInteger();
			if(b.sign()>0) RETURNconst(b_is_odd_int?InfinityNegative:InfinityPositive);
			else RETURN(b_is_odd_int?CNumber(NegativeZero):CNumber(0));
		}
	} else if(a.isZero()) {
		if(a.isNegativeZero()) {
			bool b_is_odd_int = ((b+1)/2).isInteger();
			if(b.sign()>0) RETURN(b_is_odd_int?CNumber(NegativeZero):CNumber(0));
			else RETURNconst(b_is_odd_int?InfinityNegative:InfinityPositive);
		} else 
			if(b.sign()>0) RETURN(a); else RETURNconst(InfinityPositive);
	}
	if(a.sign()<0 && !b.isInteger()) RETURNconst(NaN);

	RETURN( pow(a.toDouble(), b.toDouble()) );
*/
}

//Math.sqr(a) - returns square of given value
static void scMathSqr(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a");
	RETURN( a*a );
}

//Math.sqrt(a) - returns square root of given value
static void scMathSqrt(const CFunctionsScopePtr &c, void *userdata) {
	PARAMETER_TO_NUMBER(a,"a"); RETURN_NAN_IS_NAN(a); 
	RETURN_ZERO_IS_ZERO(a);
	if(a.sign()<0) RETURNconst(NaN);
	RETURN_INFINITY_IS_INFINITY(a); 
	RETURN( sqrt(a.toDouble()) );
}

// ----------------------------------------------- Register Functions
extern "C" void _registerMathFunctions(CTinyJS *tinyJS) {

	 CScriptVarPtr Math = tinyJS->getRoot()->addChild("Math", tinyJS->newScriptVar(Object), SCRIPTVARLINK_CONSTANT);

	 // --- Math and Trigonometry functions ---
	 tinyJS->addNative("function Math.abs(a)", scMathAbs, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.round(a)", scMathRound, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.ceil(a)", scMathCeil, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.floor(a)", scMathFloor, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.min()", scMathMin, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.max()", scMathMax, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.range(x,a,b)", scMathRange, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.sign(a)", scMathSign, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.random(a)", scMathRandom, 0, SCRIPTVARLINK_BUILDINDEFAULT);


// atan2, ceil, floor, random, round, 

	 Math->addChild("LN2", tinyJS->newScriptVar(k_LN2), SCRIPTVARLINK_CONSTANT);
	 Math->addChild("LN10", tinyJS->newScriptVar(k_LN10), SCRIPTVARLINK_CONSTANT);
	 Math->addChild("LOG2E", tinyJS->newScriptVar(k_LOG2E), SCRIPTVARLINK_CONSTANT);
	 Math->addChild("LOG10E", tinyJS->newScriptVar(k_LOG10E), SCRIPTVARLINK_CONSTANT);
	 Math->addChild("SQRT1_2", tinyJS->newScriptVar(k_SQRT1_2), SCRIPTVARLINK_CONSTANT);
	 Math->addChild("SQRT2", tinyJS->newScriptVar(k_SQRT2), SCRIPTVARLINK_CONSTANT);
	 Math->addChild("PI", tinyJS->newScriptVar(k_PI), SCRIPTVARLINK_CONSTANT);
	 tinyJS->addNative("function Math.toDegrees(a)", scMathToDegrees, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.toRadians(a)", scMathToRadians, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.sin(a)", scMathSin, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.asin(a)", scMathASin, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.cos(a)", scMathCos, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.acos(a)", scMathACos, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.tan(a)", scMathTan, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.atan(a)", scMathATan, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.atan2(a,b)", scMathATan2, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.sinh(a)", scMathSinh, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.asinh(a)", scMathASinh, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.cosh(a)", scMathCosh, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.acosh(a)", scMathACosh, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.tanh(a)", scMathTanh, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.atanh(a)", scMathATanh, 0, SCRIPTVARLINK_BUILDINDEFAULT);
		 
	 Math->addChild("E", tinyJS->newScriptVar(k_E), SCRIPTVARLINK_READONLY);
	 tinyJS->addNative("function Math.log(a)", scMathLog, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.log10(a)", scMathLog10, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.exp(a)", scMathExp, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.pow(a,b)", scMathPow, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 
	 tinyJS->addNative("function Math.sqr(a)", scMathSqr, 0, SCRIPTVARLINK_BUILDINDEFAULT);
	 tinyJS->addNative("function Math.sqrt(a)", scMathSqrt, 0, SCRIPTVARLINK_BUILDINDEFAULT);    
  
}

} /* namespace TinyJS */