neuronetwork/functions/NextMath.js

A hybrid math & neural engine with classic functions and AI computations

const Module = await import('../wasm/NextMath/build/NextMath.js');

// ✅ العمليات الأساسية
export async function NextMath_add(number, number2) {
    const instance = await Module.default();
    const result = instance._add(number, number2);
    return result;
}

export async function NextMath_subtract(number, number2) {
    const instance = await Module.default();
    const result = instance._subtract(number, number2);
    return result;
}

export async function NextMath_multiply(number, number2) {
    const instance = await Module.default();
    const result = instance._multiply(number, number2);
    return result;
}

export async function NextMath_divide(number, number2) {
    const instance = await Module.default();
    const result = instance._divide(number, number2);
    return result;
}

export async function NextMath_modulo(number, number2) {
    const instance = await Module.default();
    const result = instance._modulo(number, number2);
    return result;
}

// ✅ العمليات الرياضية المتقدمة
export async function NextMath_power(base, exponent) {
    const instance = await Module.default();
    const result = instance._power(base, exponent);
    return result;
}

export async function NextMath_sqrt(number) {
    const instance = await Module.default();
    const result = instance._sqrt_int(number);
    return result;
}

export async function NextMath_absolute(number) {
    const instance = await Module.default();
    const result = instance._absolute(number);
    return result;
}

// ✅ نظرية الأرقام
export async function NextMath_gcd(number1, number2) {
    const instance = await Module.default();
    const result = instance._gcd(number1, number2);
    return result;
}

export async function NextMath_lcm(number1, number2) {
    const instance = await Module.default();
    const result = instance._lcm(number1, number2);
    return result;
}

export async function NextMath_isPrime(number) {
    const instance = await Module.default();
    const result = instance._isPrime(number);
    return Boolean(result);
}

export async function NextMath_factorial(number) {
    const instance = await Module.default();
    const result = instance._factorial(number);
    return result;
}

export async function NextMath_fibonacci(n) {
    const instance = await Module.default();
    const result = instance._fibonacci(n);
    return result;
}

// ✅ عمليات المقارنة
export async function NextMath_max(number1, number2) {
    const instance = await Module.default();
    const result = instance._max(number1, number2);
    return result;
}

export async function NextMath_min(number1, number2) {
    const instance = await Module.default();
    const result = instance._min(number1, number2);
    return result;
}

export async function NextMath_isEven(number) {
    const instance = await Module.default();
    const result = instance._isEven(number);
    return Boolean(result);
}

export async function NextMath_isOdd(number) {
    const instance = await Module.default();
    const result = instance._isOdd(number);
    return Boolean(result);
}

// ✅ معالجة الأرقام
export async function NextMath_reverseNumber(number) {
    const instance = await Module.default();
    const result = instance._reverse_number(number);
    return result;
}

export async function NextMath_isPalindrome(number) {
    const instance = await Module.default();
    const result = instance._isPalindrome(number);
    return Boolean(result);
}

export async function NextMath_countDigits(number) {
    const instance = await Module.default();
    const result = instance._count_digits(number);
    return result;
}

export async function NextMath_sumOfDigits(number) {
    const instance = await Module.default();
    const result = instance._sum_of_digits(number);
    return result;
}

// ✅ العمليات البتية (Bitwise Operations)
export async function NextMath_xor(number1, number2) {
    const instance = await Module.default();
    const result = instance._xor_operation(number1, number2);
    return result;
}

export async function NextMath_and(number1, number2) {
    const instance = await Module.default();
    const result = instance._and_operation(number1, number2);
    return result;
}

export async function NextMath_or(number1, number2) {
    const instance = await Module.default();
    const result = instance._or_operation(number1, number2);
    return result;
}

export async function NextMath_not(number) {
    const instance = await Module.default();
    const result = instance._not_operation(number);
    return result;
}

export async function NextMath_leftShift(number, positions) {
    const instance = await Module.default();
    const result = instance._left_shift(number, positions);
    return result;
}

export async function NextMath_rightShift(number, positions) {
    const instance = await Module.default();
    const result = instance._right_shift(number, positions);
    return result;
}

// ✅ عمليات المصفوفات
export async function NextMath_average(array) {
    const instance = await Module.default();

    // تحويل المصفوفة إلى ذاكرة WASM
    const arraySize = array.length;
    const arrayPtr = instance._my_malloc(arraySize * 4); // 4 bytes per integer

    try {
        // نسخ البيانات إلى ذاكرة WASM
        for (let i = 0; i < arraySize; i++) {
            instance.HEAP32[arrayPtr / 4 + i] = array[i];
        }

        const result = instance._average(arrayPtr, arraySize);
        return result;
    } finally {
        // تحرير الذاكرة
        instance._my_free(arrayPtr);
    }
}

export async function NextMath_findMax(array) {
    const instance = await Module.default();

    const arraySize = array.length;
    const arrayPtr = instance._my_malloc(arraySize * 4);

    try {
        for (let i = 0; i < arraySize; i++) {
            instance.HEAP32[arrayPtr / 4 + i] = array[i];
        }

        const result = instance._find_max(arrayPtr, arraySize);
        return result;
    } finally {
        instance._my_free(arrayPtr);
    }
}

export async function NextMath_findMin(array) {
    const instance = await Module.default();

    const arraySize = array.length;
    const arrayPtr = instance._my_malloc(arraySize * 4);

    try {
        for (let i = 0; i < arraySize; i++) {
            instance.HEAP32[arrayPtr / 4 + i] = array[i];
        }

        const result = instance._find_min(arrayPtr, arraySize);
        return result;
    } finally {
        instance._my_free(arrayPtr);
    }
}

// ✅ دوال إضافية للاستخدام المتقدم
export async function NextMath_primeFactors(number) {
    const instance = await Module.default();
    const factors = [];
    let n = Math.abs(number);
    let divisor = 2;

    while (divisor * divisor <= n) {
        while (instance._modulo(n, divisor) === 0) {
            factors.push(divisor);
            n = instance._divide(n, divisor);
        }
        divisor = instance._add(divisor, 1);
    }

    if (n > 1) {
        factors.push(n);
    }

    return factors;
}

export async function NextMath_isPerfectNumber(number) {
    if (number <= 1) return false;

    const instance = await Module.default();
    let sum = 1; // 1 هو دائماً قاسم

    for (let i = 2; i * i <= number; i++) {
        if (instance._modulo(number, i) === 0) {
            sum = instance._add(sum, i);
            if (i !== instance._divide(number, i)) {
                sum = instance._add(sum, instance._divide(number, i));
            }
        }
    }

    return sum === number;
}

export async function NextMath_digitalRoot(number) {
    const instance = await Module.default();
    let n = instance._absolute(number);

    while (n >= 10) {
        n = instance._sum_of_digits(n);
    }

    return n;
}