Add bidirectional atan2/arctan2 support for ROOT compatibility

Fixes: ROOT aliases using 'atan2' now work in Python evaluation
- Both 'atan2' and 'arctan2' map to np.arctan2 for pandas Series
- Export converts 'arctan2' → 'atan2' for ROOT (already working)
- Complete Python ↔ ROOT roundtrip now seamless

Improvements:
- Better error messages showing available functions and hints
- Change np.array() → np.asarray() for robustness
- Add tests: bidirectional atan2 + error message validation

Tests: 33/33 passing (added 2 new tests)

Resolves "TypeError: cannot convert series to float" when
materializing ROOT-imported geometric aliases.

Author: miranov25

UTILS/dfextensions/AliasDataFrame.py

@@ -81,21 +81,20 @@ def get_func_name(n):
 # Add BEFORE class AliasDataFrame:
 
 class NumpyRootMapper:
-    """Maps NumPy function names to ROOT C++ equivalents"""
+    """Maps NumPy function names to ROOT C++ equivalents (bidirectional)"""
 
     # Maps function names to (numpy_attr, root_name)
-    # Some functions are aliases (asinh → arcsinh in numpy)
     MAPPING = {
-        # Hyperbolic functions (needed for compression)
+        # Hyperbolic functions
         'sinh': ('sinh', 'sinh'),
         'cosh': ('cosh', 'cosh'),
         'tanh': ('tanh', 'tanh'),
         'arcsinh': ('arcsinh', 'asinh'),
         'arccosh': ('arccosh', 'acosh'),
         'arctanh': ('arctanh', 'atanh'),
-        'asinh': ('arcsinh', 'asinh'),     # Alias: np.arcsinh
-        'acosh': ('arccosh', 'acosh'),     # Alias: np.arccosh
-        'atanh': ('arctanh', 'atanh'),     # Alias: np.arctanh
+        'asinh': ('arcsinh', 'asinh'),
+        'acosh': ('arccosh', 'acosh'),
+        'atanh': ('arctanh', 'atanh'),
 
         # Trigonometric
         'sin': ('sin', 'sin'),
@@ -105,9 +104,10 @@ class NumpyRootMapper:
         'arccos': ('arccos', 'acos'),
         'arctan': ('arctan', 'atan'),
         'arctan2': ('arctan2', 'atan2'),
-        'asin': ('arcsin', 'asin'),        # Alias: np.arcsin
-        'acos': ('arccos', 'acos'),        # Alias: np.arccos
-        'atan': ('arctan', 'atan'),        # Alias: np.arctan
+        'asin': ('arcsin', 'asin'),
+        'acos': ('arccos', 'acos'),
+        'atan': ('arctan', 'atan'),
+        'atan2': ('arctan2', 'atan2'),  # ← NEW: ROOT name maps to numpy
 
         # Exponential/log
         'exp': ('exp', 'exp'),
@@ -126,7 +126,11 @@ class NumpyRootMapper:
 
     @classmethod
     def get_numpy_functions_for_eval(cls):
-        """Get dict of function_name → numpy_function for evaluation"""
+        """Get dict of function_name → numpy_function for evaluation
+
+        Includes both Python names (arctan2) and ROOT names (atan2)
+        for bidirectional compatibility when reading ROOT files.
+        """
         funcs = {}
         for name, (np_attr, _) in cls.MAPPING.items():
             if hasattr(np, np_attr):
@@ -176,18 +180,21 @@ def get_subframe(self, name):
 
     def _default_functions(self):
         import math
+
+        # Start with math functions (scalar fallbacks)
         env = {k: getattr(math, k) for k in dir(math) if not k.startswith("_")}
 
-        # Add numpy functions (will override math versions with vectorized numpy)
+        # CRITICAL: Override with numpy vectorized versions
+        # This ensures both arctan2 AND atan2 map to np.arctan2
         env.update(NumpyRootMapper.get_numpy_functions_for_eval())
 
         env["np"] = np
         for sf_name, sf_entry in self._subframes.items():
             env[sf_name] = sf_entry['frame']
 
-        env["int"] = lambda x: np.array(x).astype(np.int32)
-        env["uint"] = lambda x: np.array(x).astype(np.uint32)
-        env["float"] = lambda x: np.array(x).astype(np.float32)
+        env["int"] = lambda x: np.asarray(x, dtype=np.int32)
+        env["uint"] = lambda x: np.asarray(x, dtype=np.uint32)
+        env["float"] = lambda x: np.asarray(x, dtype=np.float32)
         env["round"] = np.round
         env["clip"] = np.clip
 
@@ -250,7 +257,27 @@ def _eval_in_namespace(self, expr):
         expr = self._prepare_subframe_joins(expr)
         local_env = {col: self.df[col] for col in self.df.columns}
         local_env.update(self._default_functions())
-        return eval(expr, {}, local_env)
+
+        try:
+            return eval(expr, {}, local_env)
+        except NameError as e:
+            # Function or variable not found
+            missing_name = str(e).split("'")[1] if "'" in str(e) else "unknown"
+            available_funcs = sorted([k for k in local_env.keys() if callable(local_env.get(k))])[:20]
+            raise NameError(
+                f"Undefined function or variable '{missing_name}' in expression: {expr}\n"
+                f"Available functions include: {', '.join(available_funcs)}\n"
+                f"Hint: Common functions are available, including both 'arctan2' and 'atan2'"
+            ) from e
+        except TypeError as e:
+            if "cannot convert the series" in str(e):
+                raise TypeError(
+                    f"Scalar function used on array data in expression: {expr}\n"
+                    f"Error: {e}\n"
+                    f"Hint: All math functions should be vectorized (numpy-based). "
+                    f"If you see this with standard functions like 'atan2', please report as a bug."
+                ) from e
+            raise
 
     def _resolve_dependencies(self):
         from collections import defaultdict

UTILS/dfextensions/AliasDataFrameTest.py

@@ -109,6 +109,53 @@ def test_getattr_column_and_alias_access(self):
         expected = df["x"] + df["y"]
         np.testing.assert_array_equal(z_val, expected)
 
+    def test_bidirectional_atan2_support(self):
+        """Test that both atan2 (ROOT) and arctan2 (Python) work"""
+        df = pd.DataFrame({
+            'x': np.array([1.0, 0.0, -1.0, 0.0]),
+            'y': np.array([0.0, 1.0, 0.0, -1.0])
+        })
+        adf = AliasDataFrame(df)
+
+        # Python style (arctan2)
+        adf.add_alias('phi_python', 'arctan2(y, x)', dtype=np.float32)
+        adf.materialize_alias('phi_python')
+
+        # ROOT style (atan2) - should also work
+        adf.add_alias('phi_root', 'atan2(y, x)', dtype=np.float32)
+        adf.materialize_alias('phi_root')
+
+        # Should be identical
+        np.testing.assert_allclose(adf.df['phi_python'], adf.df['phi_root'], rtol=1e-6)
+
+        # Expected values
+        expected = np.array([0.0, np.pi/2, np.pi, -np.pi/2], dtype=np.float32)
+        np.testing.assert_allclose(adf.df['phi_python'], expected, rtol=1e-6)
+
+    def test_undefined_function_helpful_error(self):
+        """Test that undefined functions give helpful error messages"""
+        df = pd.DataFrame({'x': [1, 2, 3], 'y': [4, 5, 6]})
+        adf = AliasDataFrame(df)
+
+        # Test 1: Undefined function
+        adf.add_alias('bad', 'nonexistent_func(x)', dtype=np.float32)
+        with self.assertRaises(NameError) as cm:
+            adf.materialize_alias('bad')
+
+        error_msg = str(cm.exception)
+        # Check error message contains helpful info
+        self.assertIn('nonexistent_func', error_msg)
+        self.assertIn('Available functions include:', error_msg)
+        self.assertIn('arctan2', error_msg)  # Should mention both forms
+        self.assertIn('atan2', error_msg)
+
+        # Test 2: Undefined variable
+        adf.add_alias('bad2', 'x + undefined_var', dtype=np.float32)
+        with self.assertRaises(NameError) as cm:
+            adf.materialize_alias('bad2')
+
+        error_msg = str(cm.exception)
+        self.assertIn('undefined_var', error_msg)
 
 class TestAliasDataFrameWithSubframes(unittest.TestCase):
     def setUp(self):