voidMath_lgamma(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_lgamma>();    throw vm_system_exception{ "Function not implemented" };} voidMath_log(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_log>();    *fp.ret = std::log(fp.x);} voidMath_log10(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_log10>();    *fp.ret = std::log10(fp.x);} voidMath_log1p(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_log1p>();    *fp.ret = std::log1p(fp.x);} voidMath_modf(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_modf>();    throw vm_system_exception{ "Function not implemented" };} voidMath_nextafter(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_nextafter>();    *fp.ret = std::nextafter(fp.x, fp.y);} voidMath_norm1(vm_registers_t &r, vm_t &vm){    // Defined as: norm1(x) = sum(fabs(x[i]))    auto &fp = r.stack.peek_frame()->base<F_Math_norm1>();     auto xs = vm_alloc_t::from_allocation<vm_array_t>(fp.x);    if (xs == nullptr)        throw dereference_nil{ "norm1" };     assert(xs->get_element_type()->is_equal(intrinsic_type_desc::type<real_t>().get()));     const auto x_len = xs->get_length();    auto x_raw = reinterpret_cast<real_t *>(xs->at(0));     auto result = real_t{ 0 };    for (auto i = 0; i < x_len; ++i)        result += std::fabs(x_raw[i]);     *fp.ret = result;} voidMath_norm2(vm_registers_t &r, vm_t &vm){    // [SPEC] This function is defined as: norm2(x) = sqrt(dot(x, x))    // The Inferno implementation (libmath/blas.c) doesn't appear to take    // the square root of the resulting dot product.    auto &fp = r.stack.peek_frame()->base<F_Math_norm2>();     auto xs = vm_alloc_t::from_allocation<vm_array_t>(fp.x);    if (xs == nullptr)        throw dereference_nil{ "norm2" };     assert(xs->get_element_type()->is_equal(intrinsic_type_desc::type<real_t>().get()));     const auto x_len = xs->get_length();    auto x_raw = reinterpret_cast<real_t *>(xs->at(0));     auto result = real_t{ 0 };    for (auto i = 0; i < x_len; ++i)    {        const auto x_l = x_raw[i];        result += (x_l * x_l);    }     *fp.ret = std::sqrt(result);} voidMath_pow(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_pow>();    *fp.ret = std::pow(fp.x, fp.y);} voidMath_pow10(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_pow10>();    throw vm_system_exception{ "Function not implemented" };} voidMath_realbits32(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_realbits32>();     auto x = static_cast<float>(fp.x);    word_t t;    std::memcpy(&t, &x, sizeof(x));     *fp.ret = t;} voidMath_realbits64(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_realbits64>();     auto x = fp.x;    big_t t;    std::memcpy(&t, &x, sizeof(x));    static_assert(sizeof(t) == sizeof(x), "Real should be 64-bits");     *fp.ret = t;} voidMath_remainder(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_remainder>();    *fp.ret = std::remainder(fp.x, fp.p);} voidMath_rint(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_rint>();    *fp.ret = std::rint(fp.x);} voidMath_scalbn(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_scalbn>();    throw vm_system_exception{ "Function not implemented" };} voidMath_sin(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_sin>();    *fp.ret = std::sin(fp.x);} voidMath_sinh(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_sinh>();    *fp.ret = std::sinh(fp.x);} voidMath_sort(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_sort>();     auto reals = vm_alloc_t::from_allocation<vm_array_t>(fp.x);    auto words = vm_alloc_t::from_allocation<vm_array_t>(fp.pi);    if (reals == nullptr || words == nullptr)        throw dereference_nil{ "Sort reals" };     assert(reals->get_element_type()->is_equal(intrinsic_type_desc::type<real_t>().get()));    assert(words->get_element_type()->is_equal(intrinsic_type_desc::type<word_t>().get()));     const auto words_len = words->get_length();    if (reals->get_length() != words_len)        throw vm_user_exception{ "Array lengths must be equal" };     // Handle trivial sort cases    if (words_len <= 1)        return;     auto begin_words = reinterpret_cast<word_t *>(words->at(0));    auto end_words = begin_words + words_len;     // Validate array of indices    for (auto iter = begin_words; iter != end_words; ++iter)    {        if (*iter < 0 || words_len <= *iter)            throw vm_user_exception{ "Invalid sort index values" };    }     const auto reals_raw = reinterpret_cast<real_t *>(reals->at(0));    std::sort(begin_words, end_words, [reals_raw](word_t l, word_t r) { return reals_raw[l] < reals_raw[r]; });} voidMath_sqrt(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_sqrt>();    *fp.ret = std::sqrt(fp.x);} voidMath_tan(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_tan>();    *fp.ret = std::tan(fp.x);} voidMath_tanh(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_tanh>();    *fp.ret = std::tanh(fp.x);} voidMath_y0(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_y0>();    throw vm_system_exception{ "Function not implemented" };} voidMath_y1(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_y1>();    throw vm_system_exception{ "Function not implemented" };} voidMath_yn(vm_registers_t &r, vm_t &vm){    auto &fp = r.stack.peek_frame()->base<F_Math_yn>();    throw vm_system_exception{ "Function not implemented" };}

Lines 501–741 of 741. Previous lines