Add fxdiv (#5005)

* Add fxdiv

* add tests

* Use noarch

---------

Co-authored-by: Alexis Placet <2400067+Alex-PLACET@users.noreply.github.com>

Author: Alex-PLACET

recipes/recipes_emscripten/fxdiv/build.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+set -e
+
+cmake . \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_INSTALL_PREFIX=$PREFIX \
+  -DFXDIV_BUILD_TESTS=OFF \
+  -DFXDIV_BUILD_BENCHMARKS=OFF \
+  -Bcmake-out-wasm
+
+cmake --build cmake-out-wasm --target install

recipes/recipes_emscripten/fxdiv/build_tests.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -e
+
+export CFLAGS="${CFLAGS} ${EM_FORGE_SIDE_MODULE_CFLAGS}"
+
+echo "Building fxdiv tests with CMake..."
+
+mkdir -p build
+cd build
+
+emcmake cmake ../tests/. \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_FIND_ROOT_PATH=$PREFIX \
+  -DCMAKE_PREFIX_PATH=$PREFIX
+
+emmake make
+
+echo "Running fxdiv tests..."
+node test_fxdiv.js

recipes/recipes_emscripten/fxdiv/recipe.yaml

@@ -0,0 +1,51 @@
+context:
+  name: fxdiv
+  version: "63058eff77e11aa15bf531df5dd34395ec3017c8"
+
+package:
+  name: ${{ name }}
+  version: ${{ version }}
+
+source:
+- url: https://github.com/Maratyszcza/FXdiv/archive/${{ version }}.tar.gz
+  sha256: ec74d882a0a47cfd9c0f95bc4fae9901a4ade802a96a3b76e02671bb7340a4c5
+
+build:
+  number: 0
+  script: build.sh
+  noarch: generic
+
+requirements:
+  build:
+  - cmake
+
+tests:
+- package_contents:
+    include:
+    - fxdiv.h
+- script:
+  - build_tests.sh
+  requirements:
+    build:
+    - ${{ compiler('c') }}
+    - cmake
+    - make
+  files:
+    recipe:
+    - build_tests.sh
+    - tests/
+
+about:
+  homepage: https://github.com/Maratyszcza/FXdiv
+  license: MIT
+  license_file: LICENSE
+  summary: Header-only library for integer division via fixed-point multiplication
+  description: |
+    FXdiv is a header-only C/C++ library that implements fast integer division
+    using fixed-point multiplication. Division is replaced by a multiplication
+    and a shift, which is significantly faster than hardware integer division.
+  repository: https://github.com/Maratyszcza/FXdiv
+
+extra:
+  recipe-maintainers:
+  - Alex-PLACET

recipes/recipes_emscripten/fxdiv/tests/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.15)
+project(fxdiv_test C)
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+find_path(FXDIV_INCLUDE_DIR fxdiv.h REQUIRED)
+
+add_executable(test_fxdiv test_fxdiv.c)
+target_include_directories(test_fxdiv PRIVATE ${FXDIV_INCLUDE_DIR})

recipes/recipes_emscripten/fxdiv/tests/test_fxdiv.c

@@ -0,0 +1,82 @@
+#include <fxdiv.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static int failures = 0;
+
+#define CHECK(cond, msg) \
+    do { \
+        if (!(cond)) { \
+            fprintf(stderr, "FAIL: %s\n", msg); \
+            failures++; \
+        } else { \
+            printf("PASS: %s\n", msg); \
+        } \
+    } while (0)
+
+static void test_uint32(void) {
+    /* Basic quotient and remainder */
+    const struct fxdiv_divisor_uint32_t div7 = fxdiv_init_uint32_t(7);
+    CHECK(fxdiv_quotient_uint32_t(100, div7) == 100u / 7u, "quotient 100/7");
+    CHECK(fxdiv_remainder_uint32_t(100, div7) == 100u % 7u, "remainder 100%7");
+
+    /* divide returns both quotient and remainder */
+    const struct fxdiv_result_uint32_t r = fxdiv_divide_uint32_t(1000, div7);
+    CHECK(r.quotient == 1000u / 7u, "divide quotient 1000/7");
+    CHECK(r.remainder == 1000u % 7u, "divide remainder 1000%7");
+
+    /* round_down */
+    CHECK(fxdiv_round_down_uint32_t(13, div7) == 7u, "round_down 13 by 7");
+    CHECK(fxdiv_round_down_uint32_t(14, div7) == 14u, "round_down 14 by 7");
+
+    /* divisor of 1 */
+    const struct fxdiv_divisor_uint32_t div1 = fxdiv_init_uint32_t(1);
+    CHECK(fxdiv_quotient_uint32_t(42, div1) == 42u, "quotient 42/1");
+    CHECK(fxdiv_remainder_uint32_t(42, div1) == 0u, "remainder 42%1");
+
+    /* power-of-2 divisor */
+    const struct fxdiv_divisor_uint32_t div8 = fxdiv_init_uint32_t(8);
+    CHECK(fxdiv_quotient_uint32_t(256, div8) == 32u, "quotient 256/8");
+    CHECK(fxdiv_remainder_uint32_t(255, div8) == 7u, "remainder 255%8");
+}
+
+static void test_uint64(void) {
+    const struct fxdiv_divisor_uint64_t div13 = fxdiv_init_uint64_t(13);
+    CHECK(fxdiv_quotient_uint64_t(UINT64_C(1000000000), div13) ==
+          UINT64_C(1000000000) / UINT64_C(13), "quotient 1e9/13");
+    CHECK(fxdiv_remainder_uint64_t(UINT64_C(1000000000), div13) ==
+          UINT64_C(1000000000) % UINT64_C(13), "remainder 1e9%13");
+
+    const struct fxdiv_result_uint64_t r =
+        fxdiv_divide_uint64_t(UINT64_C(999999999999), div13);
+    CHECK(r.quotient  == UINT64_C(999999999999) / UINT64_C(13), "divide quotient large/13");
+    CHECK(r.remainder == UINT64_C(999999999999) % UINT64_C(13), "divide remainder large%13");
+
+    /* divisor of 1 */
+    const struct fxdiv_divisor_uint64_t div1 = fxdiv_init_uint64_t(1);
+    CHECK(fxdiv_quotient_uint64_t(UINT64_C(999), div1) == UINT64_C(999), "quotient 999/1");
+}
+
+static void test_size_t(void) {
+    const struct fxdiv_divisor_size_t div5 = fxdiv_init_size_t(5);
+    CHECK(fxdiv_quotient_size_t(100, div5) == (size_t)(100 / 5), "quotient 100/5 (size_t)");
+    CHECK(fxdiv_remainder_size_t(103, div5) == (size_t)(103 % 5), "remainder 103%5 (size_t)");
+
+    const struct fxdiv_result_size_t r = fxdiv_divide_size_t(99, div5);
+    CHECK(r.quotient  == (size_t)(99 / 5), "divide quotient 99/5 (size_t)");
+    CHECK(r.remainder == (size_t)(99 % 5), "divide remainder 99%5 (size_t)");
+}
+
+int main(void) {
+    test_uint32();
+    test_uint64();
+    test_size_t();
+
+    if (failures > 0) {
+        fprintf(stderr, "%d test(s) FAILED\n", failures);
+        return 1;
+    }
+    printf("All tests passed.\n");
+    return 0;
+}