Release 0.7.0: composable D operator, rename to nabla, MLE skewness vignette

Rename package from dualr to nabla and GitHub repo to queelius/nabla.
Add composable total derivative operator D(f, x, order=k) with gradient(),
hessian(), jacobian() as thin wrappers. Replace MLE-specific API with
general-purpose derivative functions. Add vignette demonstrating third-order
derivative tensors for asymptotic MLE skewness analysis on Gamma model
with Monte Carlo validation. Add Zenodo and CITATION.cff metadata.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: queelius

.Rbuildignore

@@ -10,3 +10,5 @@
 ^cran-comments\.md$
 ^CLAUDE\.md$
 ^tests/bench
+^CITATION\.cff$
+^\.zenodo\.json$

.zenodo.json

@@ -0,0 +1,43 @@
+{
+  "title": "nabla: Exact Derivatives via Automatic Differentiation",
+  "description": "Exact automatic differentiation for R functions. Provides a composable derivative operator D that computes gradients, Hessians, Jacobians, and arbitrary-order derivative tensors at machine precision. D(D(f)) gives Hessians, D(D(D(f))) gives third-order tensors for skewness of MLEs, and so on to any order. Works through any R code including loops, branches, and control flow.",
+  "creators": [
+    {
+      "name": "Towell, Alexander",
+      "affiliation": "Southern Illinois University Edwardsville",
+      "orcid": "0000-0001-6443-9897"
+    }
+  ],
+  "upload_type": "software",
+  "license": "MIT",
+  "access_right": "open",
+  "keywords": [
+    "automatic differentiation",
+    "dual numbers",
+    "forward-mode AD",
+    "gradient",
+    "Hessian",
+    "Jacobian",
+    "higher-order derivatives",
+    "R",
+    "statistics"
+  ],
+  "related_identifiers": [
+    {
+      "identifier": "https://github.com/queelius/nabla",
+      "relation": "isSupplementTo",
+      "scheme": "url"
+    },
+    {
+      "identifier": "https://cran.r-project.org/package=nabla",
+      "relation": "isIdenticalTo",
+      "scheme": "url"
+    },
+    {
+      "identifier": "https://metafunctor.com",
+      "relation": "isDocumentedBy",
+      "scheme": "url"
+    }
+  ],
+  "version": "0.7.0"
+}

CITATION.cff

@@ -0,0 +1,30 @@
+cff-version: 1.2.0
+title: "nabla: Exact Derivatives via Automatic Differentiation"
+message: "If you use this software, please cite it using these metadata."
+type: software
+authors:
+  - family-names: Towell
+    given-names: Alexander
+    alias: Alex Towell
+    email: queelius@gmail.com
+    orcid: "https://orcid.org/0000-0001-6443-9897"
+    affiliation: Southern Illinois University Edwardsville
+repository-code: "https://github.com/queelius/nabla"
+url: "https://metafunctor.com"
+abstract: >-
+  Exact automatic differentiation for R functions. Provides a composable
+  derivative operator D that computes gradients, Hessians, Jacobians, and
+  arbitrary-order derivative tensors at machine precision. Works through
+  any R code including loops, branches, and control flow.
+keywords:
+  - automatic-differentiation
+  - dual-numbers
+  - forward-mode
+  - gradient
+  - hessian
+  - jacobian
+  - higher-order-derivatives
+  - R
+license: MIT
+version: 0.7.0
+date-released: "2026-02-02"

CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## What This Is
 
-`dualr` is an R package for forward-mode automatic differentiation using dual numbers. It provides exact derivatives at machine precision through any R code (loops, branches, control flow) via operator overloading on S4 classes.
+`nabla` is an R package for exact automatic differentiation. It provides exact derivatives at machine precision through any R code (loops, branches, control flow) via operator overloading on S4 dual number classes.
 
 ## Build & Test Commands
 
@@ -46,9 +46,9 @@ The `Collate:` field in DESCRIPTION defines load order — dependencies flow top
 2. `dual-arithmetic.R` — Arithmetic operators (+, -, *, /, ^) with derivative rules; Ops/Summary group generics
 3. `dual-math.R` — Math/Math2 group generics (trig, exp, log, gamma, etc.); standalone `atan2()`, `log(x, base)`
 4. `dual-special.R` — Non-base-generic functions: `erf()`, `erfc()`, `beta()`, `lbeta()`, `psigamma()`
-5. `dual-higher.R` — Second-order via nested duals: `dual2_variable()`, `differentiate2()`
-6. `mle-helpers.R` — High-level API: `score()`, `hessian()`, `observed_information()`
-7. `dualr-package.R` — Package-level roxygen docs
+5. `dual-higher.R` — Arbitrary-order via nested duals: `dual_variable_n()`, `deriv_n()`, `differentiate_n()`
+6. `derivatives.R` — High-level API: `D()`, `gradient()`, `hessian()`, `jacobian()`
+7. `nabla-package.R` — Package-level roxygen docs
 
 ### Method Dispatch Pattern
 
@@ -65,14 +65,14 @@ The fundamental identity: `f(a + b*ε) = f(a) + f'(a)*b*ε` where `ε² = 0`.
 - Math functions apply chain rule: `deriv(f(x)) = f'(value(x)) * deriv(x)`
 - Second-order derivatives nest duals: `dual(dual(x, 1), dual(1, 0))` — after evaluation, `deriv(deriv(result))` gives f''(x)
 
-### MLE Workflow
+### Multi-Parameter Derivatives
 
-`score()` runs p forward passes (one per parameter, seeding deriv=1 on each in turn). `hessian()` uses nested duals with p*(p+1)/2 passes exploiting symmetry. Both use internal `.make_dual_vector()` / `.make_dual2_vector()` for seeding.
+`D(f)` is the composable total derivative operator. It returns the derivative of `f` as a new function; `D(D(f))` composes for higher-order derivative tensors. Each application of `D` runs `p` forward passes (one per input dimension) using `.make_dual_vector()` for seeding. `gradient()`, `hessian()`, and `jacobian()` are thin wrappers: `gradient(f, x)` = `D(f, x)`, `hessian(f, x)` = `D(f, x, order=2)`, `jacobian(f, x)` = `D(f, x)`.
 
 ## Testing Conventions
 
 - Framework: testthat 3rd edition
-- Test files mirror source structure: `test-arithmetic.R`, `test-math.R`, `test-special.R`, `test-higher-order.R`, `test-mle-helpers.R`
+- Test files mirror source structure: `test-arithmetic.R`, `test-math.R`, `test-special.R`, `test-higher-order.R`, `test-derivatives.R`
 - `test-coverage.R` targets uncovered edge cases specifically
 - `test-optimizer-integration.R` tests AD gradients with `optim()` and `nlminb()`
 - `tests/testthat/helper-numerical.R` provides `central_difference()`, `numerical_gradient()`, `numerical_hessian()` for verification

DESCRIPTION

@@ -1,17 +1,18 @@
-Package: dualr
-Title: Forward-Mode Automatic Differentiation via Dual Numbers
-Version: 0.5.0
+Package: nabla
+Title: Exact Derivatives via Automatic Differentiation
+Version: 0.7.0
 Authors@R: person("Alexander", "Towell",
                    role = c("aut", "cre"),
                    email = "queelius@gmail.com",
                    comment = c(ORCID = "0000-0001-6443-9897"))
-URL: https://github.com/queelius/dualr, https://metafunctor.com
-BugReports: https://github.com/queelius/dualr/issues
-Description: Implements forward-mode automatic differentiation using dual
-    numbers with S4 classes. Supports exact arbitrary-order derivatives
-    through recursive nesting of duals, with convenience functions for
-    maximum likelihood estimation workflows including score vectors,
-    Hessian matrices, and observed information.
+URL: https://github.com/queelius/nabla, https://metafunctor.com
+BugReports: https://github.com/queelius/nabla/issues
+Description: Exact automatic differentiation for R functions. Provides a
+    composable derivative operator D that computes gradients, Hessians,
+    Jacobians, and arbitrary-order derivative tensors at machine precision.
+    D(D(f)) gives Hessians, D(D(D(f))) gives third-order tensors for
+    skewness of MLEs, and so on to any order. Works through any R code
+    including loops, branches, and control flow.
 License: MIT + file LICENSE
 Encoding: UTF-8
 Roxygen: list(markdown = TRUE)
@@ -33,5 +34,5 @@ Collate:
     'dual-math.R'
     'dual-special.R'
     'dual-higher.R'
-    'mle-helpers.R'
-    'dualr-package.R'
+    'derivatives.R'
+    'nabla-package.R'

NAMESPACE

@@ -1,31 +1,25 @@
 # Generated by roxygen2: do not edit by hand
 
+export(D)
 export(beta)
 export(deriv)
 export(deriv_n)
-export(differentiate2)
 export(differentiate_n)
 export(dual)
-export(dual2_constant)
-export(dual2_variable)
 export(dual_constant)
 export(dual_constant_n)
 export(dual_variable)
 export(dual_variable_n)
 export(dual_vector)
 export(erf)
 export(erfc)
-export(first_deriv)
+export(gradient)
 export(hessian)
 export(is_dual)
+export(jacobian)
 export(lbeta)
-export(observed_information)
 export(psigamma)
-export(score)
-export(score_and_hessian)
-export(second_deriv)
 export(value)
-export(value2)
 exportClasses(dual_vector)
 exportClasses(dualr)
 exportMethods("!")

NEWS.md

@@ -1,4 +1,43 @@
-# dualr 0.5.0
+# nabla 0.7.0
+
+* Added vignette "Higher-Order MLE Analysis" demonstrating third-order
+  derivative tensors (`D(f, x, order = 3)`) for computing asymptotic
+  skewness of Gamma MLEs, with Monte Carlo validation.
+* Renamed package from `dualr` to `nabla`. The S4 class `dualr` retains its
+  name (it describes the object type — a dual number in R).
+* Added composable total derivative operator `D(f)`:
+  - `D(f)` returns the derivative of `f` as a new function.
+  - `D(f, x)` evaluates the derivative at `x`.
+  - `D(f, x, order = k)` applies `D` k times for k-th order derivative tensors.
+  - `D(D(f))` composes naturally for higher-order derivatives.
+  - Output tensor shape: each application of `D` appends one n-dimension.
+    For `f: R^n -> R`: gradient `(n)`, Hessian `(n,n)`, etc.
+    For `f: R^n -> R^m`: Jacobian `(m,n)`, `(m,n,n)`, etc.
+* Unified `gradient()`, `hessian()`, and `jacobian()` as thin wrappers
+  around `D`, replacing separate seeding strategies with a single composable
+  mechanism. This simplifies the codebase at the cost of `O(p)` gradient
+  (was `O(1)` passes) and `O(p^2)` Hessian (was `O(p)` passes).
+* Removed deprecated second-order functions: `dual2_variable()`,
+  `dual2_constant()`, `value2()`, `first_deriv()`, `second_deriv()`,
+  `differentiate2()`. Use `dual_variable_n()`, `dual_constant_n()`,
+  `deriv_n()`, and `differentiate_n()` instead.
+* Removed internal helpers `.make_grad_vector()` and `.make_grad2_vector()`.
+* Updated higher-order vignette to use current API and demonstrate `D` operator.
+
+# nabla 0.6.0
+
+* Replaced MLE-specific API with general-purpose derivative functions:
+  - `score()` -> `gradient()` — computes the gradient of any scalar-valued
+    function (still single-pass via vector-valued derivatives).
+  - `hessian()` — unchanged (already mathematically general).
+  - `observed_information()` — removed (trivial: just `-hessian()`).
+  - `score_and_hessian()` -> `jacobian()` — generalized to compute the
+    full m x p Jacobian matrix of any `f: R^p -> R^m`. Accepts functions
+    returning lists, numeric vectors, or scalar dualr objects.
+* Renamed `R/mle-helpers.R` to `R/derivatives.R`.
+* Updated vignettes to use general terminology (gradient/Hessian/Jacobian).
+
+# nabla 0.5.0
 
 * Generalized to arbitrary-order exact derivatives via recursive nesting.
   New API: `dual_variable_n()`, `dual_constant_n()`, `deriv_n()`,
@@ -11,7 +50,7 @@
   wrappers around the new generalized API.
 * Removed benchmarks (speed is not this package's value proposition).
 
-# dualr 0.4.0
+# nabla 0.4.0
 
 * `score()` now computes the full gradient in 1 forward pass (was p passes)
   using vector-valued derivatives, exploiting the `ANY` slots of the `dualr` class.
@@ -20,13 +59,13 @@
 * Internal `.is_scalar_dual()` now also checks `length() == 1L` to correctly
   distinguish scalar duals (C++ fast path) from vector-gradient duals (R path).
 
-# dualr 0.3.0
+# nabla 0.3.0
 
 * Added Rcpp-based C++ fast paths for first-order dual arithmetic (`+`, `-`, `*`, `/`, `^`), math (`exp`, `sqrt`, `log`), and `sum`. Provides 3-10x speedup on scalar dual operations while preserving full R fallback for nested (second-order) duals.
 * New internal `.is_scalar_dual()` predicate gates C++ vs R paths using `is.double()` on slot contents.
 * Added `Rcpp` to `Imports` and `LinkingTo`; package now requires C++ compilation.
 
-# dualr 0.2.0
+# nabla 0.2.0
 
 * Renamed S4 class from `dual` to `dualr` to avoid conflict with base R's `dual` usage.
 * Added dedicated `setMethod` dispatches for hot-path arithmetic (`+`, `-`, `*`, `/`, `^`) and math (`exp`, `sqrt`) operations, bypassing group generic overhead.
@@ -35,7 +74,7 @@
 * Standardized `sum()` in `Summary` group generic to use `.as_dual()` promotion, consistent with `prod`, `min`, `max`, and `range`.
 * Fixed stale `\code{compositional.mle}` reference in `score()` documentation.
 
-# dualr 0.1.0
+# nabla 0.1.0
 
 * Initial CRAN release.
 * S4 dual number class with full arithmetic and math function support.