duk_bi_math.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Typedefs
typedef double(*	duk__one_arg_func) (double)
typedef double(*	duk__two_arg_func) (double, double)

Functions
DUK_LOCAL duk_ret_t	duk__math_minmax (duk_context *ctx, duk_double_t initial, duk__two_arg_func min_max)
DUK_LOCAL double	duk__fmin_fixed (double x, double y)
DUK_LOCAL double	duk__fmax_fixed (double x, double y)
DUK_LOCAL double	duk__round_fixed (double x)
DUK_LOCAL double	duk__pow_fixed (double x, double y)
DUK_LOCAL double	duk__fabs (double x)
DUK_LOCAL double	duk__acos (double x)
DUK_LOCAL double	duk__asin (double x)
DUK_LOCAL double	duk__atan (double x)
DUK_LOCAL double	duk__ceil (double x)
DUK_LOCAL double	duk__cos (double x)
DUK_LOCAL double	duk__exp (double x)
DUK_LOCAL double	duk__floor (double x)
DUK_LOCAL double	duk__log (double x)
DUK_LOCAL double	duk__sin (double x)
DUK_LOCAL double	duk__sqrt (double x)
DUK_LOCAL double	duk__tan (double x)
DUK_LOCAL double	duk__atan2 (double x, double y)
DUK_INTERNAL duk_ret_t	duk_bi_math_object_onearg_shared (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_math_object_twoarg_shared (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_math_object_max (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_math_object_min (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_math_object_random (duk_context *ctx)

Variables
DUK_LOCAL const duk__one_arg_func	duk__one_arg_funcs []
DUK_LOCAL const duk__two_arg_func	duk__two_arg_funcs []

Typedef Documentation

duk__one_arg_func

typedef double(* duk__one_arg_func) (double)

Definition at line 18 of file duktape-1.5.2/src-separate/duk_bi_math.c.

duk__two_arg_func

typedef double(* duk__two_arg_func) (double, double)

Definition at line 19 of file duktape-1.5.2/src-separate/duk_bi_math.c.

Function Documentation

duk__acos()

DUK_LOCAL double duk__acos

(

double

x

)

Definition at line 202 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                     {
    return DUK_ACOS(x);
}

References DUK_ACOS.

duk__asin()

DUK_LOCAL double duk__asin

(

double

x

)

Definition at line 205 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                     {
    return DUK_ASIN(x);
}

References DUK_ASIN.

duk__atan()

DUK_LOCAL double duk__atan

(

double

x

)

Definition at line 208 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                     {
    return DUK_ATAN(x);
}

References DUK_ATAN.

duk__atan2()

DUK_LOCAL double duk__atan2	(	double	x,
		double	y )

Definition at line 235 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                {
    return DUK_ATAN2(x, y);
}

References DUK_ATAN2.

duk__ceil()

DUK_LOCAL double duk__ceil

(

double

x

)

Definition at line 211 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                     {
    return DUK_CEIL(x);
}

References DUK_CEIL.

duk__cos()

DUK_LOCAL double duk__cos

(

double

x

)

Definition at line 214 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                    {
    return DUK_COS(x);
}

References DUK_COS.

duk__exp()

DUK_LOCAL double duk__exp

(

double

x

)

Definition at line 217 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                    {
    return DUK_EXP(x);
}

References DUK_EXP.

duk__fabs()

DUK_LOCAL double duk__fabs

(

double

x

)

Definition at line 199 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                     {
    return DUK_FABS(x);
}

References DUK_FABS.

duk__floor()

DUK_LOCAL double duk__floor

(

double

x

)

Definition at line 220 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                      {
    return DUK_FLOOR(x);
}

References DUK_FLOOR.

duk__fmax_fixed()

DUK_LOCAL double duk__fmax_fixed	(	double	x,
		double	y )

Definition at line 71 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                     {
    /* fmax() with args -0 and +0 is not guaranteed to return
     * +0 as Ecmascript requires.
     */
    if (x == 0 && y == 0) {
        if (DUK_SIGNBIT(x) == 0 || DUK_SIGNBIT(y) == 0) {
            return +0.0;
        } else {
            return -0.0;
        }
    }
#ifdef DUK_USE_MATH_FMAX
    return DUK_FMAX(x, y);
#else
    return (x > y ? x : y);
#endif
}

References DUK_FMAX, and DUK_SIGNBIT.

Referenced by duk_bi_math_object_max().

duk__fmin_fixed()

DUK_LOCAL double duk__fmin_fixed	(	double	x,
		double	y )

Definition at line 52 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                     {
    /* fmin() with args -0 and +0 is not guaranteed to return
     * -0 as Ecmascript requires.
     */
    if (x == 0 && y == 0) {
        /* XXX: what's the safest way of creating a negative zero? */
        if (DUK_SIGNBIT(x) != 0 || DUK_SIGNBIT(y) != 0) {
            return -0.0;
        } else {
            return +0.0;
        }
    }
#ifdef DUK_USE_MATH_FMIN
    return DUK_FMIN(x, y);
#else
    return (x < y ? x : y);
#endif
}

References DUK_FMIN, and DUK_SIGNBIT.

Referenced by duk_bi_math_object_min().

duk__log()

DUK_LOCAL double duk__log

(

double

x

)

Definition at line 223 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                    {
    return DUK_LOG(x);
}

References DUK_LOG.

duk__math_minmax()

DUK_LOCAL duk_ret_t duk__math_minmax	(	duk_context *	ctx,
		duk_double_t	initial,
		duk__two_arg_func	min_max )

Definition at line 21 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                                                                        {
    duk_idx_t n = duk_get_top(ctx);
    duk_idx_t i;
    duk_double_t res = initial;
    duk_double_t t;
 
    /*
     *  Note: fmax() does not match the E5 semantics.  E5 requires
     *  that if -any- input to Math.max() is a NaN, the result is a
     *  NaN.  fmax() will return a NaN only if -both- inputs are NaN.
     *  Same applies to fmin().
     *
     *  Note: every input value must be coerced with ToNumber(), even
     *  if we know the result will be a NaN anyway: ToNumber() may have
     *  side effects for which even order of evaluation matters.
     */
 
    for (i = 0; i < n; i++) {
        t = duk_to_number(ctx, i);
        if (DUK_FPCLASSIFY(t) == DUK_FP_NAN || DUK_FPCLASSIFY(res) == DUK_FP_NAN) {
            /* Note: not normalized, but duk_push_number() will normalize */
            res = (duk_double_t) DUK_DOUBLE_NAN;
        } else {
            res = (duk_double_t) min_max(res, (double) t);
        }
    }
 
    duk_push_number(ctx, res);
    return 1;
}

References DUK_DOUBLE_NAN, DUK_FP_NAN, DUK_FPCLASSIFY, duk_get_top(), duk_push_number(), and duk_to_number().

Referenced by duk_bi_math_object_max(), and duk_bi_math_object_min().

duk__pow_fixed()

DUK_LOCAL double duk__pow_fixed	(	double	x,
		double	y )

Definition at line 130 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                    {
    /* The ANSI C pow() semantics differ from Ecmascript.
     *
     * E.g. when x==1 and y is +/- infinite, the Ecmascript required
     * result is NaN, while at least Linux pow() returns 1.
     */
 
    duk_small_int_t cx, cy, sx;
 
    DUK_UNREF(cx);
    DUK_UNREF(sx);
    cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
 
    if (cy == DUK_FP_NAN) {
        goto ret_nan;
    }
    if (DUK_FABS(x) == 1.0 && cy == DUK_FP_INFINITE) {
        goto ret_nan;
    }
#if defined(DUK_USE_POW_NETBSD_WORKAROUND)
    /* See test-bug-netbsd-math-pow.js: NetBSD 6.0 on x86 (at least) does not
     * correctly handle some cases where x=+/-0.  Specific fixes to these
     * here.
     */
    cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
    if (cx == DUK_FP_ZERO && y < 0.0) {
        sx = (duk_small_int_t) DUK_SIGNBIT(x);
        if (sx == 0) {
            /* Math.pow(+0,y) should be Infinity when y<0.  NetBSD pow()
             * returns -Infinity instead when y is <0 and finite.  The
             * if-clause also catches y == -Infinity (which works even
             * without the fix).
             */
            return DUK_DOUBLE_INFINITY;
        } else {
            /* Math.pow(-0,y) where y<0 should be:
             *   - -Infinity if y<0 and an odd integer
             *   - Infinity otherwise
             * NetBSD pow() returns -Infinity for all finite y<0.  The
             * if-clause also catches y == -Infinity (which works even
             * without the fix).
             */
 
            /* fmod() return value has same sign as input (negative) so
             * the result here will be in the range ]-2,0], 1 indicates
             * odd.  If x is -Infinity, NaN is returned and the odd check
             * always concludes "not odd" which results in desired outcome.
             */
            double tmp = DUK_FMOD(y, 2);
            if (tmp == -1.0) {
                return -DUK_DOUBLE_INFINITY;
            } else {
                /* Not odd, or y == -Infinity */
                return DUK_DOUBLE_INFINITY;
            }
        }
    }
#endif
    return DUK_POW(x, y);
 
 ret_nan:
    return DUK_DOUBLE_NAN;
}

References DUK_DOUBLE_INFINITY, DUK_DOUBLE_NAN, DUK_FABS, DUK_FMOD, DUK_FP_INFINITE, DUK_FP_NAN, DUK_FP_ZERO, DUK_FPCLASSIFY, DUK_POW, DUK_SIGNBIT, and DUK_UNREF.

duk__round_fixed()

DUK_LOCAL double duk__round_fixed

(

double

x

)

Definition at line 89 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                            {
    /* Numbers half-way between integers must be rounded towards +Infinity,
     * e.g. -3.5 must be rounded to -3 (not -4).  When rounded to zero, zero
     * sign must be set appropriately.  E5.1 Section 15.8.2.15.
     *
     * Note that ANSI C round() is "round to nearest integer, away from zero",
     * which is incorrect for negative values.  Here we make do with floor().
     */
 
    duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x);
    if (c == DUK_FP_NAN || c == DUK_FP_INFINITE || c == DUK_FP_ZERO) {
        return x;
    }
 
    /*
     *  x is finite and non-zero
     *
     *  -1.6 -> floor(-1.1) -> -2
     *  -1.5 -> floor(-1.0) -> -1  (towards +Inf)
     *  -1.4 -> floor(-0.9) -> -1
     *  -0.5 -> -0.0               (special case)
     *  -0.1 -> -0.0               (special case)
     *  +0.1 -> +0.0               (special case)
     *  +0.5 -> floor(+1.0) -> 1   (towards +Inf)
     *  +1.4 -> floor(+1.9) -> 1
     *  +1.5 -> floor(+2.0) -> 2   (towards +Inf)
     *  +1.6 -> floor(+2.1) -> 2
     */
 
    if (x >= -0.5 && x < 0.5) {
        /* +0.5 is handled by floor, this is on purpose */
        if (x < 0.0) {
            return -0.0;
        } else {
            return +0.0;
        }
    }
 
    return DUK_FLOOR(x + 0.5);
}

References DUK_FLOOR, DUK_FP_INFINITE, DUK_FP_NAN, DUK_FP_ZERO, and DUK_FPCLASSIFY.

duk__sin()

DUK_LOCAL double duk__sin

(

double

x

)

Definition at line 226 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                    {
    return DUK_SIN(x);
}

References DUK_SIN.

duk__sqrt()

DUK_LOCAL double duk__sqrt

(

double

x

)

Definition at line 229 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                     {
    return DUK_SQRT(x);
}

References DUK_SQRT.

duk__tan()

DUK_LOCAL double duk__tan

(

double

x

)

Definition at line 232 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                    {
    return DUK_TAN(x);
}

References DUK_TAN.

duk_bi_math_object_max()

DUK_INTERNAL duk_ret_t duk_bi_math_object_max

(

duk_context *

ctx

)

Definition at line 306 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                                {
    return duk__math_minmax(ctx, -DUK_DOUBLE_INFINITY, duk__fmax_fixed);
}

References duk__fmax_fixed(), duk__math_minmax(), and DUK_DOUBLE_INFINITY.

duk_bi_math_object_min()

DUK_INTERNAL duk_ret_t duk_bi_math_object_min

(

duk_context *

ctx

)

Definition at line 310 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                                {
    return duk__math_minmax(ctx, DUK_DOUBLE_INFINITY, duk__fmin_fixed);
}

References duk__fmin_fixed(), duk__math_minmax(), and DUK_DOUBLE_INFINITY.

duk_bi_math_object_onearg_shared()

DUK_INTERNAL duk_ret_t duk_bi_math_object_onearg_shared

(

duk_context *

ctx

)

Definition at line 284 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                                          {
    duk_small_int_t fun_idx = duk_get_current_magic(ctx);
    duk__one_arg_func fun;
 
    DUK_ASSERT(fun_idx >= 0);
    DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__one_arg_funcs) / sizeof(duk__one_arg_func)));
    fun = duk__one_arg_funcs[fun_idx];
    duk_push_number(ctx, (duk_double_t) fun((double) duk_to_number(ctx, 0)));
    return 1;
}

References duk__one_arg_funcs, DUK_ASSERT, duk_get_current_magic(), duk_push_number(), and duk_to_number().

duk_bi_math_object_random()

DUK_INTERNAL duk_ret_t duk_bi_math_object_random

(

duk_context *

ctx

)

Definition at line 314 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                                   {
    duk_push_number(ctx, (duk_double_t) duk_util_tinyrandom_get_double((duk_hthread *) ctx));
    return 1;
}

References duk_push_number(), and duk_util_tinyrandom_get_double().

duk_bi_math_object_twoarg_shared()

DUK_INTERNAL duk_ret_t duk_bi_math_object_twoarg_shared

(

duk_context *

ctx

)

Definition at line 295 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                                          {
    duk_small_int_t fun_idx = duk_get_current_magic(ctx);
    duk__two_arg_func fun;
 
    DUK_ASSERT(fun_idx >= 0);
    DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__two_arg_funcs) / sizeof(duk__two_arg_func)));
    fun = duk__two_arg_funcs[fun_idx];
    duk_push_number(ctx, (duk_double_t) fun((double) duk_to_number(ctx, 0), (double) duk_to_number(ctx, 1)));
    return 1;
}

References duk__two_arg_funcs, DUK_ASSERT, duk_get_current_magic(), duk_push_number(), and duk_to_number().

Variable Documentation

duk__one_arg_funcs

DUK_LOCAL const duk__one_arg_func duk__one_arg_funcs[]

Definition at line 241 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                         {
#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
    duk__fabs,
    duk__acos,
    duk__asin,
    duk__atan,
    duk__ceil,
    duk__cos,
    duk__exp,
    duk__floor,
    duk__log,
    duk__round_fixed,
    duk__sin,
    duk__sqrt,
    duk__tan
#else
    DUK_FABS,
    DUK_ACOS,
    DUK_ASIN,
    DUK_ATAN,
    DUK_CEIL,
    DUK_COS,
    DUK_EXP,
    DUK_FLOOR,
    DUK_LOG,
    duk__round_fixed,
    DUK_SIN,
    DUK_SQRT,
    DUK_TAN
#endif
};

Referenced by duk_bi_math_object_onearg_shared().

duk__two_arg_funcs

DUK_LOCAL const duk__two_arg_func duk__two_arg_funcs[]

Initial value:

= {
 
    duk__atan2,
    duk__pow_fixed
 
 
 
 
}

Definition at line 274 of file duktape-1.5.2/src-separate/duk_bi_math.c.

                                                         {
#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
    duk__atan2,
    duk__pow_fixed
#else
    DUK_ATAN2,
    duk__pow_fixed
#endif
};

Referenced by duk_bi_math_object_twoarg_shared().