Add inverse hyperbolic funcs

Author: FrancescAlted

src/blosc2/lazyexpr.py

@@ -1276,12 +1276,6 @@ def fast_eval(  # noqa: C901
     # Check whether we can use miniexpr
     # Miniexpr only supports a subset of functions - disable for unsupported ones
     unsupported_funcs = [
-        "acosh",
-        "arccosh",
-        "arcsinh",
-        "arctanh",
-        "asinh",
-        "atanh",
         "clip",
         "conj",
         "expm1",

src/blosc2/miniexpr.c

@@ -523,13 +523,19 @@ static const me_variable functions[] = {
     /* Format: {name, dtype, address, type, context} */
     {"abs", 0, fabs, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"acos", 0, acos, ME_FUNCTION1 | ME_FLAG_PURE, 0},
+    {"acosh", 0, acosh, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"arccos", 0, acos, ME_FUNCTION1 | ME_FLAG_PURE, 0},
+    {"arccosh", 0, acosh, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"arcsin", 0, asin, ME_FUNCTION1 | ME_FLAG_PURE, 0},
+    {"arcsinh", 0, asinh, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"arctan", 0, atan, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"arctan2", 0, atan2, ME_FUNCTION2 | ME_FLAG_PURE, 0},
+    {"arctanh", 0, atanh, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"asin", 0, asin, ME_FUNCTION1 | ME_FLAG_PURE, 0},
+    {"asinh", 0, asinh, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"atan", 0, atan, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"atan2", 0, atan2, ME_FUNCTION2 | ME_FLAG_PURE, 0},
+    {"atanh", 0, atanh, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"ceil", 0, ceil, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"cos", 0, cos, ME_FUNCTION1 | ME_FLAG_PURE, 0},
     {"cosh", 0, cosh, ME_FUNCTION1 | ME_FLAG_PURE, 0},
@@ -1835,6 +1841,7 @@ DEFINE_VEC_CONVERT(u32, bool, uint32_t, bool)
 DEFINE_VEC_CONVERT(u64, bool, uint64_t, bool)
 DEFINE_VEC_CONVERT(f32, bool, float, bool)
 DEFINE_VEC_CONVERT(f64, bool, double, bool)
+DEFINE_VEC_CONVERT(f64, f32, double, float)
 
 DEFINE_VEC_CONVERT(i8, i16, int8_t, int16_t)
 DEFINE_VEC_CONVERT(i8, i32, int8_t, int32_t)
@@ -1876,7 +1883,6 @@ DEFINE_VEC_CONVERT(u32, f64, uint32_t, double)
 DEFINE_VEC_CONVERT(u64, f64, uint64_t, double)
 
 DEFINE_VEC_CONVERT(f32, f64, float, double)
-DEFINE_VEC_CONVERT(f64, f32, double, float)
 DEFINE_VEC_CONVERT(f32, c64, float, float complex)
 DEFINE_VEC_CONVERT(f32, c128, float, double complex)
 
@@ -1956,10 +1962,10 @@ static convert_func_t get_convert_func(me_dtype from, me_dtype to) {
     CONV_CASE(ME_UINT64, ME_FLOAT64, u64, f64)
 
     CONV_CASE(ME_FLOAT32, ME_FLOAT64, f32, f64)
-    CONV_CASE(ME_FLOAT64, ME_FLOAT32, f64, f32)
     CONV_CASE(ME_FLOAT32, ME_COMPLEX64, f32, c64)
     CONV_CASE(ME_FLOAT32, ME_COMPLEX128, f32, c128)
 
+    CONV_CASE(ME_FLOAT64, ME_FLOAT32, f64, f32)
     CONV_CASE(ME_FLOAT64, ME_COMPLEX128, f64, c128)
 
     CONV_CASE(ME_COMPLEX64, ME_COMPLEX128, c64, c128)

src/blosc2/miniexpr.h

@@ -118,7 +118,8 @@ typedef struct me_variable {
  *   var_count: Number of variables
  *   dtype: Data type handling:
  *          - ME_AUTO: All variables must specify their dtypes, output is inferred
- *          - Specific type: All variables must be ME_AUTO, this type is used for all
+ *          - Specific type: Either all variables are ME_AUTO (homogeneous, all use this type),
+ *            OR all variables have explicit dtypes (heterogeneous, result cast to this type)
  *   error: Optional pointer to receive error position (0 on success, >0 on error)
  *
  * Returns: Compiled expression ready for chunked evaluation, or NULL on error
@@ -127,10 +128,15 @@ typedef struct me_variable {
  *   me_variable vars[] = {{"x"}, {"y"}};  // Both ME_AUTO
  *   me_expr *expr = me_compile("x + y", vars, 2, ME_FLOAT64, &err);
  *
- * Example 2 (mixed types):
+ * Example 2 (mixed types with ME_AUTO):
  *   me_variable vars[] = {{"x", ME_INT32}, {"y", ME_FLOAT64}};
  *   me_expr *expr = me_compile("x + y", vars, 2, ME_AUTO, &err);
  *
+ * Example 3 (mixed types with explicit output):
+ *   me_variable vars[] = {{"x", ME_INT32}, {"y", ME_FLOAT64}};
+ *   me_expr *expr = me_compile("x + y", vars, 2, ME_FLOAT32, &err);
+ *   // Variables keep their types, result is cast to FLOAT32
+ *
  *   // Later, provide data in same order as variable definitions
  *   const void *data[] = {x_array, y_array};  // x first, y second
  *   me_eval(expr, data, 2, output, nitems);