Update v0.0.8

Author: jaydu1

README.md

@@ -29,7 +29,16 @@ For optimal parallel performance, we recommend installing `llvm-openmp` if using
 conda install -c conda-forge llvm-openmp
 ```
 
-For `R` users, `reticulate` can be used to call `causarray` from `R`.
+For `R` users, `reticulate` can be used to call `causarray` from R while
+keeping NumPy >2 in the Python environment. Create the separate R environment
+with a current NumPy-2-compatible reticulate build:
+
+```bash
+conda env create -f environment-r.yaml
+```
+
+The R tutorial runs from `causarray-r` and connects to the Python package in
+the `causarray` environment.
 The documentation and tutorials using both `Python` and `R` are available at [causarray.readthedocs.io](https://causarray.readthedocs.io/en/latest/).
 
 

causarray/DR_learner.py

@@ -10,6 +10,24 @@
 from causarray.utils import reset_random_seeds, pprint, tqdm, comp_size_factor, _filter_params
 
 
+def _add_log2fc_columns(df_res):
+    """Add base-2 LFC aliases while retaining natural-log result columns."""
+    log2 = np.log(2.0)
+    log2fc = df_res['tau'].to_numpy() / log2
+    log2fc_se = df_res['std'].to_numpy() / log2
+
+    # Recompute existing aliases as well as missing ones.  This normalizes
+    # mixed old/new frames loaded from resumable batch caches and guarantees
+    # that the aliases remain exact transformations of tau and std.
+    for name in ('log2fc', 'log2fc_se'):
+        if name in df_res.columns:
+            df_res.pop(name)
+    insert_at = df_res.columns.get_loc('std') + 1
+    df_res.insert(insert_at, 'log2fc', log2fc)
+    df_res.insert(insert_at + 1, 'log2fc_se', log2fc_se)
+    return df_res
+
+
 
 def compute_causal_estimand(
     estimand,
@@ -369,9 +387,17 @@ def LFC(
     Returns
     -------
     df_res : DataFrame
-        Test results with effect estimates and inference columns, raw
-        ``mean_control`` and ``mean_treated`` counterfactual means, and an
-        ``estimable`` flag (plus ``trt`` for multiple treatments).
+        Test results with natural-log effect estimate ``tau`` and standard
+        error ``std``, together with their base-2 equivalents ``log2fc`` and
+        ``log2fc_se``. The fold change is treatment relative to control, and
+        ``log2fc_se`` is a standard error (not a sample standard deviation).
+        The result also contains inference columns, raw ``mean_control`` and
+        ``mean_treated`` counterfactual means, and an ``estimable`` flag (plus
+        ``trt`` for multiple treatments).
+
+        .. versionadded:: 0.0.8
+            Added the ``log2fc`` and ``log2fc_se`` convenience columns. The
+            original natural-log ``tau`` and ``std`` columns remain unchanged.
     """
 
     def estimand(etas, A, **kwargs):
@@ -458,12 +484,13 @@ def estimand(etas, A, **kwargs):
     if K is None:
         K = 2 if cross_est else 1
 
-    return compute_causal_estimand(
+    df_res, estimation = compute_causal_estimand(
         estimand, Y, W, A, W_A, family, offset,    
         Y_hat=Y_hat, pi_hat=pi_hat, mask=mask,
         fdx=fdx, fdx_alpha=fdx_alpha, fdx_c=fdx_c,
         verbose=verbose, backend=backend, K=K, ps_clip=ps_clip,
         ps_class_weight=ps_class_weight, **kwargs)
+    return _add_log2fc_columns(df_res), estimation
 
 
 
@@ -662,8 +689,10 @@ def gcate_lfc_batch(
     Returns
     -------
     df_res : DataFrame
-        Concatenated result from all batches.  Includes a ``'batch'``
-        column with the 0-based batch index so batches can be identified.
+        Concatenated result from all batches. Includes natural-log ``tau`` and
+        ``std`` columns, base-2 ``log2fc`` and ``log2fc_se`` columns, and a
+        ``'batch'`` column with the 0-based batch index. Older compatible
+        caches containing only ``tau`` and ``std`` are upgraded in memory.
     """
     import gc
     from causarray.gcate import fit_gcate_batch
@@ -834,7 +863,7 @@ def gcate_lfc_batch(
         result = pd.concat(
             [new_dfs[i] for i in all_indices], axis=0
         ).reset_index(drop=True)
-    return result
+    return _add_log2fc_columns(result)
 
 
 def LFC_batch(*args, **kwargs):

causarray/__about__.py

@@ -1 +1 @@
-__version__ = "0.0.7"
+__version__ = "0.0.8"

docs/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.0.8] - 2026-07-20
+
+### Added
+
+- `LFC()` and `gcate_lfc_batch()` results now include `log2fc` and
+  `log2fc_se`, the base-2 equivalents of the existing natural-log `tau` and
+  `std` columns. Existing statistics, p-values, and discoveries are unchanged.
+
+### Changed
+
+- Older compatible `gcate_lfc_batch()` caches are upgraded in memory with the
+  new log2-scale columns when resumed.
+- The Python environment now requires NumPy >2. A separate `causarray-r`
+  environment supplies R 4.4 and a NumPy-2-compatible `reticulate`, avoiding
+  changes to the Python numerical stack for R interoperability.
+
 ## [0.0.7] - 2026-07-18
 
 ### Added

docs/source/main_function/lfc.rst

@@ -9,6 +9,28 @@ with effect estimates, standard errors, and BH-adjusted p-values.
 For screens with hundreds of perturbations use :func:`gcate_lfc_batch`, which
 runs GCATE and LFC in batches to keep peak memory bounded.
 
+Effect-size columns
+-------------------
+
+The returned DataFrame reports the treatment-versus-control effect on both
+natural-log and base-2 scales:
+
+=================  ===========================================================
+Column             Definition
+=================  ===========================================================
+``tau``            Natural logarithm of the treated/control mean ratio.
+``std``            Standard error of ``tau`` on the natural-log scale.
+``log2fc``         Base-2 log fold change, exactly ``tau / log(2)``.
+``log2fc_se``      Standard error of ``log2fc``, exactly ``std / log(2)``.
+=================  ===========================================================
+
+``log2fc_se`` is the standard error of the estimated log2 fold change, not the
+sample standard deviation of expression. The rescaling leaves ``stat``,
+p-values, adjusted p-values, and discoveries unchanged. ``tau`` and ``std``
+remain available for backward compatibility. The same columns are returned by
+``gcate_lfc_batch``; compatible caches made by older versions are upgraded in
+memory when loaded.
+
 Choosing the variance estimator
 -------------------------------