Merge pull request #58 from smups/dev

Update CI to use new release branch

Author: smups

.github/workflows/CI.yml

@@ -3,8 +3,7 @@ name: CI
 on:
   push:
     branches:
-      - main
-      - master
+      - release
     tags:
       - '*'
   pull_request:
@@ -114,9 +113,9 @@ jobs:
     strategy:
       matrix:
         platform:
-          - runner: macos-12
+          - runner: macos-13
             target: x86_64
-          - runner: macos-14
+          - runner: macos-latest
             target: aarch64
     steps:
       - uses: actions/checkout@v4
@@ -161,7 +160,7 @@ jobs:
   pypi-publish:
     name: Release
     runs-on: ubuntu-latest
-    if: "startsWith(github.ref_name, 'master')"
+    if: "startsWith(github.ref_name, 'release')"
     needs: [linux, windows, macos, sdist]
     permissions:
       id-token: write

python/inflatox/__init__.py

@@ -25,13 +25,16 @@
 
 from . import consistency_conditions
 from . import background
+from .libinflx_rs import log_info, log_warn
 
 __all__ = [
     "CompilationArtifact",
     "Compiler",
     "InflationModel",
     "InflationModelBuilder",
     "consistency_conditions",
+    "log_info",
+    "log_warn",
     "background",
     "__version__",
 ]

python/inflatox/compiler.py

@@ -405,10 +405,13 @@ def _generate_c_function(
             if not self.silent:
                 print(f"Found {len(cse_list[0])} common subexpressions")
             for cse_symbol, cse_definition in cse_list[0]:
-                out += f"    const double {printer.doprint(cse_symbol)} = {printer.doprint(cse_definition)};\n"
-            out += f"    return {printer.doprint(cse_list[1])}{';\n}\n'}"
+                out += f"    const double {printer.doprint(cse_symbol)} = {printer.doprint(cse_definition)};"
+                out += "\n"
+            out += f"    return {printer.doprint(cse_list[1])};"
+            out += "\n}\n"
         else:
-            out += f"    return {printer.doprint(body)}{';\n}\n'}"
+            out += f"    return {printer.doprint(body)};"
+            out += "\n}\n"
         return out + "\n"
 
     def _generate_c_function_for_vector(
@@ -424,15 +427,17 @@ def _generate_c_function_for_vector(
             if not self.silent:
                 print(f"Found {len(cse_list[0])} common subexpressions")
             for cse_symbol, cse_definition in cse_list[0]:
-                out += f"    const double {printer.doprint(cse_symbol)} = {printer.doprint(cse_definition)};\n"
+                out += f"    const double {printer.doprint(cse_symbol)} = {printer.doprint(cse_definition)};"
+                out += "\n"
             for output_expr in cse_list[1]:
                 ordered_output_expr.append(output_expr)
         else:
             ordered_output_expr = vector
 
         # Assign each element of the output vector to a component of the vector
         for i, output_cmp in enumerate(ordered_output_expr):
-            out += f"    v_out[{i}] = {printer.doprint(output_cmp)};\n"
+            out += f"    v_out[{i}] = {printer.doprint(output_cmp)};"
+            out += "\n"
         out += "    return;\n}\n\n"
 
         return out
@@ -446,7 +451,8 @@ def _generate_c_function_for_inner_prod(self, printer: CInflatoxPrinter) -> str:
         if self.cse:
             cse_list = sympy.cse(flattened_metric, symbols=self._new_cse_generator(), list=True)
             for cse_symbol, cse_definition in cse_list[0]:
-                out += f"    const double {printer.doprint(cse_symbol)} = {printer.doprint(cse_definition)};\n"
+                out += f"    const double {printer.doprint(cse_symbol)} = {printer.doprint(cse_definition)};"
+                out += "\n"
             flattened_metric = cse_list[1]
 
         # Write function for outer product
@@ -458,9 +464,11 @@ def _generate_c_function_for_inner_prod(self, printer: CInflatoxPrinter) -> str:
                 symbol_str = printer.doprint(flattened_metric[n])
                 if symbol_str == "0" or symbol_str == "0.0":
                     continue
-                out += f"    const double g{i}{j} = {symbol_str};\n"
+                out += f"    const double g{i}{j} = {symbol_str};"
+                out += "\n"
                 return_expr += f" + (g{i}{j} * v1[{i}] * v2[{j}])"
-        out += f"    return {return_expr};\n}}\n\n"
+        out += f"    return {return_expr};"
+        out += "\n}\n\n"
         return out
 
     def _generate_c_file(self):

python/inflatox/symbolic.py

@@ -20,6 +20,8 @@
 import numpy as np
 import sympy
 from interruptingcow import timeout
+import os
+from . import libinflx_rs
 from joblib import Parallel, cpu_count, delayed
 from sympy.simplify import sqrtdenest
 from sympy.vector import Gradient
@@ -140,6 +142,9 @@ def new(
         This class will automatically derive names for the derivatives of the fields (these are
         used by other inflatox components when solving the equations of motion).
 
+        Simplifications are currently disabled on windows due to their time-out system relying on
+        UNIX signals.
+
         ### Args
         - `fields` (`list[sympy.Symbol]`): list of sympy symbols that should be
           interpreted as fields (coordinates on the scalar manifold).
@@ -156,7 +161,9 @@ def new(
         - `assertions` (`bool`, *optional*): if False, expensive intermediate
           assertions will be disabled. Defaults to False.
         - `simplify` (`bool`, *optional*): When `True` `sympy`'s simplify method will be used.
-          Defaults to `True`.
+          Due to the time-out system for simplifications relying on UNIX signals, simplifications
+          cannot be turned on on Windows. If you set `simplify` to `True` on Windows it will be
+          ignored. Defaults to `True` (except on Windows platforms).
         - `simplify_timeout` (`float`, *optional*): time-out time in seconds for simplification
           steps.
 
@@ -167,6 +174,21 @@ def new(
         if init_sympy_printing:
             sympy.init_printing()
 
+        if simplify == True and os.name == "nt":
+            libinflx_rs.log_warn(
+                "cannot use simplifications on Windows. Continuing without simplifications."
+            )
+            return cls(
+                fields=fields,
+                field_metric=field_metric,
+                potential=potential,
+                model_name=model_name if model_name is not None else "generic model",
+                silent=silent,
+                assertions=assertions,
+                simplify=False,
+                simplify_timeout=0.0,
+            )
+
         return cls(
             fields=fields,
             field_metric=field_metric,
@@ -208,7 +230,7 @@ def __init__(
 
     def simplify_expr(self, expr: sympy.Expr) -> sympy.Expr:
         """simplifies expression"""
-        if not self.simplify:
+        if not self.simplify or os.name == "nt":
             return expr
         try:
             with timeout(self.simplify_timeout, exception=SimplificationTimeOut):
@@ -220,7 +242,7 @@ def simplify_expr(self, expr: sympy.Expr) -> sympy.Expr:
 
     def expand_and_factor_expr(self, expr: sympy.Expr) -> sympy.Expr:
         """`sympy.expand` followed by `sympy.factor` with a time-out"""
-        if not self.simplify:
+        if not self.simplify or os.name == "nt":
             return expr
         try:
             with timeout(self.simplify_timeout, exception=SimplificationTimeOut):
@@ -232,7 +254,7 @@ def expand_and_factor_expr(self, expr: sympy.Expr) -> sympy.Expr:
 
     def sqrt_and_denest_expr(self, expr: sympy.Expr) -> sympy.Expr:
         """returns denested square root of expr (with timeout)"""
-        if not self.simplify:
+        if not self.simplify or os.name == "nt":
             return sympy.sqrt(expr)
         try:
             with timeout(self.simplify_timeout, exception=SimplificationTimeOut):
@@ -527,6 +549,8 @@ def calc_gradient_square(self) -> sympy.Expr:
         for a in range(dim):
             for b in range(dim):
                 out += metric_inv[a, b] * gradient[a] * gradient[b]
+        if os.name == "nt":
+            return self.simplify_expr(out)
         try:
             with timeout(self.simplify_timeout, exception=SimplificationTimeOut):
                 out = sympy.factor(sympy.expand(out))
@@ -599,6 +623,9 @@ def gramm_schmidt(
             xdoty = self.inner_prod(x, y)
             for a in range(dim):
                 y[a] -= xdoty * x[a]
+        # Disable simplification if we're on Windows
+        if os.name == "nt":
+            return [self.simplify_expr(yi) for yi in self.normalize(y)]
         try:
             with timeout(self.simplify_timeout, exception=SimplificationTimeOut):
                 y = [sympy.factor(sympy.expand(yi)) for yi in y]

src/lib.rs

@@ -71,6 +71,8 @@ fn libinflx_rs(_py: Python<'_>, pymod: &Bound<PyModule>) -> PyResult<()> {
   use anguelova::*;
   pymod.add_class::<InflatoxPyDyLib>()?;
   pymod.add_function(wrap_pyfunction!(open_inflx_dylib, pymod)?)?;
+  pymod.add_function(wrap_pyfunction!(log_info, pymod)?)?;
+  pymod.add_function(wrap_pyfunction!(log_warn, pymod)?)?;
 
   pymod.add_function(wrap_pyfunction!(flag_quantum_dif_py, pymod)?)?;
   pymod.add_function(wrap_pyfunction!(consistency_only, pymod)?)?;
@@ -89,6 +91,16 @@ fn libinflx_rs(_py: Python<'_>, pymod: &Bound<PyModule>) -> PyResult<()> {
   Ok(())
 }
 
+#[pyfunction]
+fn log_info<'py>(msg: Bound<'py, pyo3::types::PyString>) {
+  eprintln!("{}{}", *BADGE_INFO, msg.to_string());
+}
+
+#[pyfunction]
+fn log_warn<'py>(msg: Bound<'py, pyo3::types::PyString>) {
+  eprintln!("{}{}", *BADGE_WARN, msg.to_string());
+}
+
 #[pyclass]
 /// Python wrapper for `InflatoxDyLib`
 pub struct InflatoxPyDyLib(pub InflatoxDylib);