Changelog

capybara 2.0.0

  • Capybara now offers different variance-covariance estimators that do not require to call summary() (e.g., this differens from Alpaca). I added a vignette replicating Cameron and Miller (2014) to show how to use 1-way, 2-way, and dyadic clustering.
  • Improved numerical robustness of convergence criteria across all fitting functions (fepoisson_asymmetric(), feglm_fit(), fenegbin_fit()) to handle FMA (Fused Multiply-Add) compiler optimizations on macOS and ARM. Convergence checks now use hybrid absolute + relative tolerance thresholds that scale appropriately, and bias correction now uses stronger ridge regularization for numerical stability. This eliminates intermittent convergence failures across different platforms and compiler configurations.
  • Besides vcov estimation, capybara now allows to update formulas, which is explained in the vcov vignette. tldr; you can use fml <- mpg ~ wt | am followed by felm(update(fml, . ~ . | cyl), data = mtcars and variations of (same for feglm() and cluster update)
  • I rewrote the the Rank-Revealing Cholesky general method to contribute back to Armadillo.
  • I found an error when using summary(lm/glm, type = "clustered") that largely underestimated the standard errors. This is now fixed and I merged “clustered” and ” sandwich” types into a single “sandwich” type for clarity and consistency as both use a bread-meat-bread approach.
  • The InferenceGLM struct now adds the VCOV matrix and the standard errors to reuse computation and
    strealine the summary creation. Same for the InferenceLM struct.
  • All the inference (std. error, R-squared, etc) was moved to C++ side and print() and summary() functions just format the output.
  • Allows formulas without fixed effects, such as y ~ x1 + x2 and y ~ x1 + x2 | 0 | cluster and formulas without slopes such as y ~ 0 | fe1 + fe2.
  • Allows offsets in GLMs.
  • All the computation is done on C++ side, and now model formulas explicitly fail if there are functions inside them.
  • The default is now predict(glm_object, type = "response"), unlike base R behavior.
  • Most of the R and C++ code was refactored to use memory efficiently.
  • Follows fixest-based normalization for fixed effects to match Stata results.
  • Provides the option to use control = list(centering = "berge") or list(centering = "stammann"). Both methods are equivalent but use different internal logics. Berge’s fixed point problem approach is usually faster.
  • Supports Probit and Logit regression.
  • Adds parallelization over columns for an efficient centering regardless of the method used.
  • A new function fepoisson_asymmetric() to compare coefficients across expectiles (e.g., 10%, 50%, 90%) to weight positive/negative residuals. This is based on “The Tails of Gravity” (10.1016/j.jinteco.2025.104145). The argument expectile_glm_iter_max in fit_control() controls the number of inner GLM iterations per APPML step. Setting it to 1L updates asymmetric weights at every Newton step instead of only after the inner GLM converges, which typically reduces total iterations needed.
  • The summary_table() function now accepts positioning arguments for LaTeX.
  • Improved numerical robustness of convergence criteria across all fitting functions (fepoisson_asymmetric(), feglm_fit(), fenegbin_fit()) to handle FMA (Fused Multiply-Add) compiler optimizations on macOS and ARM. Convergence checks now use hybrid absolute + relative tolerance thresholds that scale appropriately, eliminating intermittent convergence failures across different platforms and compiler configurations.

capybara 1.8.1

  • Link to published article and citation info.

capybara 1.8.0

  • Drops congujate gradient acceleration and uses Irons-Tuck acceleration instead. It is slightly faster.
  • The benchmarks show a small overhead compared to fixest, which is much smaller memory footprint.

capybara 1.7.0

  • All the computation is done on C++ side. R does just do the data cleaning/wrangling.
  • Implements a rank-revealing Cholesky factorisation like fixest.
  • Returns estimated fixed effects by default (with an option not to).

capybara 1.6.0

  • Handles collinearities in the model matrix by using a QR decomposition. when Cholesky fails.
  • It can return NA coefficients when there is collinearity to match base R outputs.

capybara 1.4.0

  • Adds an extended battery of optional tests for the Poisson model.
  • Modular code for easier maintenance.

capybara 1.3.0

  • Explicitly avoids Intel MKL and fallbacks to OpenBLAS to avoid issues with non reproducible results.
  • Uses OpenMP to parallelize the demeaning functions, which can lead to significant speedups in large datasets.
  • Uses Irons-Tuck acceleration for fast convergence in the demeaning functions.

capybara 1.2.0

  • Changes to fit and summary functions to report perfectly classified observations.
  • Dropped linear dependence checks, leaving it to the Cholesky decomposition to handle it.

capybara 1.1.0

  • The workhorse demeaning functions were rewritten towards a more efficient implementation. This is based on ppmlhdfe and fixest code.
  • Loops were avoided and replace with efficient matrix operations.

capybara 1.0.3

  • Implements some ideas from reghdfe/ppmlhdfe to improve the centering/demeaning functions.

capybara 1.0.2

  • Small refactors for speed.

capybara 1.0.1

  • The examples now use smaller datasets to avoid CRAN timeouts with Clang-ASAN.

capybara 1.0.0

  • Implements a new approach to obtain the rank with a QR decomposition without loss of stability.
  • Adds different refactors to:
    • Streamline the code
    • Pass all large objects by reference
    • Use BLAS/LAPACK instead of iteration for some operations
  • Uses a new configure file that works nicely with Intel MKL (i.e. the user does not need to export environment variables for the package to detect MKL).

capybara 0.9.6

  • Calculates the rank of matrix X based on singular value decomposition instead of QR decomposition. This is more efficient and numerically stable.

capybara 0.9.5

  • Fixes and expands the ‘weights’ argument in the fe*() functions to allow for different types of weights. The default is still NULL (i.e., all weights equal to 1). The argument now admits weights passed as weights = ~cyl, weights = mtcars$cyl, or w <- mtcars$cyl; weights = w.

capybara 0.9.4

  • Allows to estimate models without fixed effects.

capybara 0.9.3

  • Fixes the tidy() method for linear models (felm class). Now it does not require to load the tibble package to work.
  • Adds a wrapper to present multiple models into a single table with the option to export to LaTeX.

capybara 0.9.2

  • Implements Irons and Tuck acceleration for fast convergence.

capybara 0.9.1

  • Fixes a minor uninitialized variable in the C++ code used for a conditional check.

capybara 0.9

  • First CRAN version

  • Refactored functions to avoid data copies:

    • center variables
    • crossprod
    • GLM and LM fit
    • get alpha
    • group sums
    • mu eta
    • variance

  • iter_center_max and iter_inner_max now can be modified in feglm_control().

capybara 0.8.0

  • Dedicated functions for linear models to avoid the overhead of running the GLM function with a Gaussian link.

capybara 0.7.0

  • The predict method now allows to pass new data to predict the outcome.
  • Fully documented code and tests according to rOpenSci standards.

capybara 0.6.0

  • Moves all the heavy computation to C++ using Armadillo and it exports the results to R. Previously, there were multiple data copies between R and C++ that added overhead to the computations.
  • The previous versions returned MX by default, now it has to be specified.
  • Adds code to extract the fixed effects with felm objects.

capybara 0.5.2

  • Uses an O(n log(n)) algorithm to compute the Kendall correlation for the pseudo-R2 in the Poisson model.

capybara 0.5.1

  • Using arma::field consistently instead of std::vector<std::vector<>> for indices.
  • Linear algebra changes, such as using arma::inv instead of solving arma::qr for the inverse.
  • Replaces multiple for loops with dedicated Armadillo functions.

capybara 0.5.0

  • Avoids for loops in the C++ code, and instead uses Armadillo’s functions.
  • O(n) computations in C++ access data directly by using pointers.

capybara 0.4.6

  • Fixes notes from tidyselect regarding the use of all_of().
  • The C++ code follows a more consistent style.
  • The GH-Actions do not test gcc 4.8 anymore.

capybara 0.4.5

  • Ungroups the data to avoid issues with the model matrix

capybara 0.4

  • Uses R’s C API efficiently to add a bit more of memory optimizations

capybara 0.3.5

  • Uses Mat consistently for all matrix operations (avoids vectors)

capybara 0.3

  • Reduces memory footprint ~45% by moving some computation to Armadillo’s side

capybara 0.2

  • Includes pseudo R2 (same as Stata) for Poisson models

capybara 0.1

  • Initial CRAN submission.

Loading...