SEC [ helpsmego.digital ]

Linux premium110.web-hosting.com 4.18.0-553.84.1.lve.el8.x86_64 #1 SMP Tue Nov 25 18:33:03 UTC 2025 x86_64

LiteSpeed

199.188.201.155 | Your IP: 216.73.216.6

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ opt / cloudlinux / venv / lib / python3.11 / site-packages / numpy / core / tests / data /

Home Upload Mass Deface Mass Delete Back Connect Info Server

Server Info

Operating System	:	Linux premium110.web-hosting.com 4.18.0-553.84.1.lve.el8.x86_64 #1 SMP Tue Nov 25 18:33:03 UTC 2025 x86_64
User / Group	:	2062[decaawyr] / 2057[decaawyr]
PHP Version	:	7.4.33
IP Server	:	199.188.201.155
Your IP	:	216.73.216.6
Storage	:	Total = 48.91 GB, Free = 32.41 GB [66%]
Domains	:	Cant read [ /etc/named.conf ]
Software	:	LiteSpeed
Disable Functions	:	All function is accessible
Useful Functions	:	gcc, lcc, cc, ld, make, php, perl, python, ruby, tar, gzip, bzip, bzialfa2, nc, locate, suidperl, git, docker, ssh
Downloader	:	wget, fetch, lynx, links, curl, get, lwp-mirror
CURL : ON \| SSH2 : OFF \| Magic Quotes : ON \| MySQL : ON \| MSSQL : OFF \| PostgreSQL : ON \| Oracle : OFF
Safe Mode : OFF \| Open Basedir : NONE \| Safe Mode Exec Dir : NONE \| Safe Mode Include Dir : NONE

generate_umath_validation_data.cpp

#include <algorithm>
#include <fstream>
#include <iostream>
#include <math.h>
#include <random>
#include <cstdio>
#include <ctime>
#include <vector>

struct ufunc {
    std::string name;
    double (*f32func)(double);
    long double (*f64func)(long double);
    float f32ulp;
    float f64ulp;
};

template <typename T>
T
RandomFloat(T a, T b)
{
    T random = ((T)rand()) / (T)RAND_MAX;
    T diff = b - a;
    T r = random * diff;
    return a + r;
}

template <typename T>
void
append_random_array(std::vector<T> &arr, T min, T max, size_t N)
{
    for (size_t ii = 0; ii < N; ++ii)
        arr.emplace_back(RandomFloat<T>(min, max));
}

template <typename T1, typename T2>
std::vector<T1>
computeTrueVal(const std::vector<T1> &in, T2 (*mathfunc)(T2))
{
    std::vector<T1> out;
    for (T1 elem : in) {
        T2 elem_d = (T2)elem;
        T1 out_elem = (T1)mathfunc(elem_d);
        out.emplace_back(out_elem);
    }
    return out;
}

/*
 * FP range:
 * [-inf, -maxflt, -1., -minflt, -minden, 0., minden, minflt, 1., maxflt, inf]
 */

#define MINDEN std::numeric_limits<T>::denorm_min()
#define MINFLT std::numeric_limits<T>::min()
#define MAXFLT std::numeric_limits<T>::max()
#define INF std::numeric_limits<T>::infinity()
#define qNAN std::numeric_limits<T>::quiet_NaN()
#define sNAN std::numeric_limits<T>::signaling_NaN()

template <typename T>
std::vector<T>
generate_input_vector(std::string func)
{
    std::vector<T> input = {MINDEN,  -MINDEN, MINFLT, -MINFLT, MAXFLT,
                            -MAXFLT, INF,     -INF,   qNAN,    sNAN,
                            -1.0,    1.0,     0.0,    -0.0};

// [-1.0, 1.0]
    if ((func == "arcsin") || (func == "arccos") || (func == "arctanh")) {
        append_random_array<T>(input, -1.0, 1.0, 700);
    }
    // (0.0, INF]
    else if ((func == "log2") || (func == "log10")) {
        append_random_array<T>(input, 0.0, 1.0, 200);
        append_random_array<T>(input, MINDEN, MINFLT, 200);
        append_random_array<T>(input, MINFLT, 1.0, 200);
        append_random_array<T>(input, 1.0, MAXFLT, 200);
    }
    // (-1.0, INF]
    else if (func == "log1p") {
        append_random_array<T>(input, -1.0, 1.0, 200);
        append_random_array<T>(input, -MINFLT, -MINDEN, 100);
        append_random_array<T>(input, -1.0, -MINFLT, 100);
        append_random_array<T>(input, MINDEN, MINFLT, 100);
        append_random_array<T>(input, MINFLT, 1.0, 100);
        append_random_array<T>(input, 1.0, MAXFLT, 100);
    }
    // [1.0, INF]
    else if (func == "arccosh") {
        append_random_array<T>(input, 1.0, 2.0, 400);
        append_random_array<T>(input, 2.0, MAXFLT, 300);
    }
    // [-INF, INF]
    else {
        append_random_array<T>(input, -1.0, 1.0, 100);
        append_random_array<T>(input, MINDEN, MINFLT, 100);
        append_random_array<T>(input, -MINFLT, -MINDEN, 100);
        append_random_array<T>(input, MINFLT, 1.0, 100);
        append_random_array<T>(input, -1.0, -MINFLT, 100);
        append_random_array<T>(input, 1.0, MAXFLT, 100);
        append_random_array<T>(input, -MAXFLT, -100.0, 100);
    }

std::random_shuffle(input.begin(), input.end());
    return input;
}

int
main()
{
    srand(42);
    std::vector<struct ufunc> umathfunc = {
            {"sin", sin, sin, 1.49, 1.00},
            {"cos", cos, cos, 1.49, 1.00},
            {"tan", tan, tan, 3.91, 3.93},
            {"arcsin", asin, asin, 3.12, 2.55},
            {"arccos", acos, acos, 2.1, 1.67},
            {"arctan", atan, atan, 2.3, 2.52},
            {"sinh", sinh, sinh, 1.55, 1.89},
            {"cosh", cosh, cosh, 2.48, 1.97},
            {"tanh", tanh, tanh, 1.38, 1.19},
            {"arcsinh", asinh, asinh, 1.01, 1.48},
            {"arccosh", acosh, acosh, 1.16, 1.05},
            {"arctanh", atanh, atanh, 1.45, 1.46},
            {"cbrt", cbrt, cbrt, 1.94, 1.82},
            //{"exp",exp,exp,3.76,1.53},
            {"exp2", exp2, exp2, 1.01, 1.04},
            {"expm1", expm1, expm1, 2.62, 2.1},
            //{"log",log,log,1.84,1.67},
            {"log10", log10, log10, 3.5, 1.92},
            {"log1p", log1p, log1p, 1.96, 1.93},
            {"log2", log2, log2, 2.12, 1.84},
    };

for (int ii = 0; ii < umathfunc.size(); ++ii) {
        // ignore sin/cos
        if ((umathfunc[ii].name != "sin") && (umathfunc[ii].name != "cos")) {
            std::string fileName =
                    "umath-validation-set-" + umathfunc[ii].name + ".csv";
            std::ofstream txtOut;
            txtOut.open(fileName, std::ofstream::trunc);
            txtOut << "dtype,input,output,ulperrortol" << std::endl;

// Single Precision
            auto f32in = generate_input_vector<float>(umathfunc[ii].name);
            auto f32out = computeTrueVal<float, double>(f32in,
                                                        umathfunc[ii].f32func);
            for (int jj = 0; jj < f32in.size(); ++jj) {
                txtOut << "np.float32" << std::hex << ",0x"
                       << *reinterpret_cast<uint32_t *>(&f32in[jj]) << ",0x"
                       << *reinterpret_cast<uint32_t *>(&f32out[jj]) << ","
                       << ceil(umathfunc[ii].f32ulp) << std::endl;
            }

// Double Precision
            auto f64in = generate_input_vector<double>(umathfunc[ii].name);
            auto f64out = computeTrueVal<double, long double>(
                    f64in, umathfunc[ii].f64func);
            for (int jj = 0; jj < f64in.size(); ++jj) {
                txtOut << "np.float64" << std::hex << ",0x"
                       << *reinterpret_cast<uint64_t *>(&f64in[jj]) << ",0x"
                       << *reinterpret_cast<uint64_t *>(&f64out[jj]) << ","
                       << ceil(umathfunc[ii].f64ulp) << std::endl;
            }
            txtOut.close();
        }
    }
    return 0;
}

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2025-05-15 07:01:09
..	dir	-	root/root	drwxr-xr-x	2025-05-15 07:01:09
astype_copy.pkl	application/octet-stream	716 B	root/root	-rw-r--r--	2025-04-17 01:10:58
generate_umath_validation_data.cpp	text/x-c++	5.71 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
recarray_from_file.fits	image/fits	8.44 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-README.txt	text/plain	967 B	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-arccos.csv	text/plain	59.93 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-arccosh.csv	text/plain	59.93 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-arcsin.csv	text/plain	59.9 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-arcsinh.csv	text/plain	58.88 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-arctan.csv	text/plain	58.89 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-arctanh.csv	text/plain	59.9 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-cbrt.csv	text/plain	59.42 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-cos.csv	text/plain	57.74 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-cosh.csv	text/plain	59.44 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-exp.csv	text/plain	17.08 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-exp2.csv	text/plain	57.25 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-expm1.csv	text/plain	58.89 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-log.csv	text/plain	11.42 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-log10.csv	text/plain	67.31 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-log1p.csv	text/plain	58.89 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-log2.csv	text/plain	67.3 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-sin.csv	text/plain	57.24 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-sinh.csv	text/plain	58.88 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-tan.csv	text/plain	58.89 KB	root/root	-rw-r--r--	2025-04-17 01:10:58
umath-validation-set-tanh.csv	text/plain	58.89 KB	root/root	-rw-r--r--	2025-04-17 01:10:58