Prep for CRAN: docs, examples, DESCRIPTION, wire up missing C bindings

DESCRIPTION rewritten for CRAN: title and description narrowed to
Linux-focused libtorch bindings, Cornball AI added as copyright holder
to match LICENSE, ORCID on the maintainer, single-quoted software
names, pytorch cppdocs URL angle-bracketed and updated to the new host,
OS_type: unix.

Deleted R/zzz-compat-ops.R (1108 lines of auto-generated torch wrappers
with no callers, riddled with undefined helpers copied from the 'torch'
R package). Killed the only glue::glue usage while we were in there.

Wired three C++ functions that had implementations in src/gen-ops.cpp
but were never registered with R, so their R wrappers were effectively
stubs:

- cuda_synchronize() now walks every CUDA device and calls
  cudaDeviceSynchronize(). CUDA work is NOT implicitly synced at the R
  boundary; explicit sync matters for benchmarking and surfacing async
  errors. Added a new C_cuda_synchronize in src/tensor.cpp.
- torch_manual_seed() now calls at::manual_seed(). Verified
  reproducibility across torch_randn() calls.
- torch_scaled_mm() now calls at::_scaled_mm(). Verified with an FP8
  matmul on CUDA.

Each got matching stubs in src/stubs.c, entries in init.cpp's
CallEntries table, Rcpp wrappers in RcppExports.cpp, and R bindings in
R/RcppExports.R.

Example coverage: 270 examples copied verbatim from the 'torch' R
package via tools/copy_examples.R (matched by topic name), 56
hand-written stubs for functions with no torch counterpart, and 650+
template examples pointing at the upstream PyTorch docs for the
mechanical torch_* wrappers. All examples are wrapped in
\\donttest{if (torch_is_installed()) { ... }}.

Parameter docs: tools/add_param_docs.R parses function signatures,
diffs against existing @param lines, and fills in missing ones from a
small type-aware description table. 306 @param lines added across the
generated op wrappers and the hand-written compat shims.

Other fixes: -2147483648L integer literal in torch_iinfo() (triggered
'non-integer value ... qualified with L'), torch::cuda_is_available()
references in examples switched to the tinytorch-local function, stale
tinytorch_0.1.0.tar.gz / tinytorch.Rcheck / tinyrox*.log cleaned up
and added to .Rbuildignore.

Status: 0 errors, 0 warnings, 2 notes. The remaining notes are the
private cornball-ai/tinytorch URL (will 404 until the repo is public)
and the standard Debian/Ubuntu system-R compile flags.

NEWS.md and cran-comments.md added.

Author: TroyHernandez

.Rbuildignore

@@ -12,3 +12,8 @@
 ^tools$
 ^src/Makevars$
 ^run\.sh$
+^tinytorch\.Rcheck$
+^tinytorch_.*\.tar\.gz$
+^cran-comments\.md$
+^tinyrox.*\.log$
+^\.Rhistory$

DESCRIPTION

@@ -1,17 +1,21 @@
 Package: tinytorch
 Type: Package
-Title: High-Performance R Bindings to Libtorch
+Title: Minimal R Bindings to 'libtorch' (Linux)
 Version: 0.2.0
 Authors@R: c(
     person("Troy", "Hernandez", role = c("aut", "cre"),
-           email = "troy@cornball.ai"),
+           email = "troy@cornball.ai",
+           comment = c(ORCID = "0009-0005-4248-604X")),
+    person("Cornball AI", role = "cph"),
     person("Daniel", "Falbel", role = "ctb",
-           comment = "torch R package (optimizer, distribution, data loading, and nn module designs adapted under MIT license)")
+           comment = "portions adapted from the 'torch' R package under MIT license")
     )
-Description: Direct R bindings to 'libtorch' (PyTorch C++ distribution) with
-    minimal overhead. Installs on all platforms; full functionality requires
-    'libtorch' on Linux (see README). Provides a 'torch'-compatible API that
-    eliminates intermediate layers for maximum performance on tensor operations.
+Description: Direct R bindings to 'libtorch', the C++ distribution of
+    'PyTorch' <https://docs.pytorch.org/cppdocs/>. Links against a system
+    'libtorch' shared library on Linux and exposes tensor operations,
+    autograd, and neural network building blocks through a 'torch'-compatible
+    API. On other platforms the package installs with a stub backend and
+    'is_available()' returns 'FALSE'. The only hard dependency is 'Rcpp'.
 Encoding: UTF-8
 License: MIT + file LICENSE
 URL: https://github.com/cornball-ai/tinytorch
@@ -21,5 +25,6 @@ Imports: Rcpp
 LinkingTo: Rcpp
 Suggests: tinytest, simplermarkdown
 VignetteBuilder: simplermarkdown
+OS_type: unix
 NeedsCompilation: yes
-SystemRequirements: LibTorch (PyTorch C++ distribution, optional); see README
+SystemRequirements: libtorch (C++ distribution of 'PyTorch'); see README

NAMESPACE

@@ -117,7 +117,6 @@ export(local_enable_grad)
 export(local_no_grad)
 export(local_torch_manual_seed)
 export(loop)
-export(lp_pool_nd)
 export(lr_cosine_annealing)
 export(lr_lambda)
 export(lr_multiplicative)
@@ -132,21 +131,16 @@ export(nn_adaptive_log_softmax_with_loss)
 export(nn_adaptive_max_pool1d)
 export(nn_adaptive_max_pool2d)
 export(nn_adaptive_max_pool3d)
-export(nn_aum_loss)
 export(nn_avg_pool1d)
 export(nn_avg_pool2d)
 export(nn_avg_pool3d)
-export(nn_batch_norm_)
 export(nn_batch_norm1d)
 export(nn_batch_norm2d)
 export(nn_batch_norm3d)
 export(nn_bce_loss)
 export(nn_bce_with_logits_loss)
-export(nn_bilinear)
 export(nn_buffer)
 export(nn_celu)
-export(nn_contrib_sparsemax)
-export(nn_conv_nd)
 export(nn_conv_transpose1d)
 export(nn_conv_transpose2d)
 export(nn_conv_transpose3d)
@@ -157,15 +151,11 @@ export(nn_cosine_embedding_loss)
 export(nn_cross_entropy_loss)
 export(nn_ctc_loss)
 export(nn_dropout)
-export(nn_dropout_nd)
 export(nn_dropout2d)
 export(nn_dropout3d)
 export(nn_elu)
 export(nn_embedding)
-export(nn_embedding_bag)
 export(nn_flatten)
-export(nn_fractional_max_pool2d)
-export(nn_fractional_max_pool3d)
 export(nn_gelu)
 export(nn_glu)
 export(nn_group_norm)
@@ -199,28 +189,18 @@ export(nn_leaky_relu)
 export(nn_linear)
 export(nn_log_sigmoid)
 export(nn_log_softmax)
-export(nn_loss)
-export(nn_lp_pool1d)
-export(nn_lp_pool2d)
 export(nn_lstm)
 export(nn_margin_ranking_loss)
-export(nn_max_pool_nd)
 export(nn_max_pool1d)
 export(nn_max_pool2d)
 export(nn_max_pool3d)
-export(nn_max_unpool1d)
-export(nn_max_unpool2d)
-export(nn_max_unpool3d)
 export(nn_module)
 export(nn_module_dict)
 export(nn_module_list)
 export(nn_mse_loss)
 export(nn_multi_margin_loss)
-export(nn_multihead_attention)
 export(nn_multilabel_margin_loss)
-export(nn_multilabel_soft_margin_loss)
 export(nn_nll_loss)
-export(nn_norm_base_)
 export(nn_pairwise_distance)
 export(nn_parameter)
 export(nn_poisson_nll_loss)
@@ -229,7 +209,6 @@ export(nn_prune_head)
 export(nn_relu)
 export(nn_relu6)
 export(nn_rnn)
-export(nn_rnn_base)
 export(nn_rrelu)
 export(nn_selu)
 export(nn_sequential)
@@ -246,10 +225,7 @@ export(nn_softsign)
 export(nn_tanh)
 export(nn_tanhshrink)
 export(nn_threshold)
-export(nn_transformer_encoder)
-export(nn_transformer_encoder_layer)
 export(nn_triplet_margin_loss)
-export(nn_triplet_margin_with_distance_loss)
 export(nn_unflatten)
 export(nn_upsample)
 export(nn_utils_clip_grad_norm_)
@@ -259,16 +235,13 @@ export(nn_utils_rnn_pack_sequence)
 export(nn_utils_rnn_pad_packed_sequence)
 export(nn_utils_rnn_pad_sequence)
 export(nn_utils_weight_norm)
-export(nn_weighted_loss)
 export(nnf_adaptive_avg_pool1d)
 export(nnf_adaptive_avg_pool2d)
 export(nnf_adaptive_avg_pool3d)
 export(nnf_adaptive_max_pool1d)
 export(nnf_adaptive_max_pool2d)
 export(nnf_adaptive_max_pool3d)
-export(nnf_affine_grid)
 export(nnf_alpha_dropout)
-export(nnf_area_under_min_fpr_fnr)
 export(nnf_avg_pool1d)
 export(nnf_avg_pool2d)
 export(nnf_avg_pool3d)
@@ -278,7 +251,6 @@ export(nnf_binary_cross_entropy)
 export(nnf_binary_cross_entropy_with_logits)
 export(nnf_celu)
 export(nnf_celu_)
-export(nnf_contrib_sparsemax)
 export(nnf_conv_tbc)
 export(nnf_conv_transpose1d)
 export(nnf_conv_transpose2d)
@@ -297,14 +269,11 @@ export(nnf_elu)
 export(nnf_elu_)
 export(nnf_embedding)
 export(nnf_embedding_bag)
-export(nnf_fold)
 export(nnf_fractional_max_pool2d)
 export(nnf_fractional_max_pool3d)
 export(nnf_gelu)
 export(nnf_glu)
-export(nnf_grid_sample)
 export(nnf_group_norm)
-export(nnf_gumbel_softmax)
 export(nnf_hardshrink)
 export(nnf_hardsigmoid)
 export(nnf_hardswish)
@@ -318,23 +287,17 @@ export(nnf_l1_loss)
 export(nnf_layer_norm)
 export(nnf_leaky_relu)
 export(nnf_linear)
-export(nnf_local_response_norm)
 export(nnf_log_softmax)
 export(nnf_logsigmoid)
-export(nnf_lp_pool1d)
-export(nnf_lp_pool2d)
 export(nnf_margin_ranking_loss)
 export(nnf_max_pool1d)
 export(nnf_max_pool2d)
 export(nnf_max_pool3d)
-export(nnf_max_unpool1d)
 export(nnf_max_unpool2d)
 export(nnf_max_unpool3d)
 export(nnf_mse_loss)
-export(nnf_multi_head_attention_forward)
 export(nnf_multi_margin_loss)
 export(nnf_multilabel_margin_loss)
-export(nnf_multilabel_soft_margin_loss)
 export(nnf_nll_loss)
 export(nnf_normalize)
 export(nnf_one_hot)
@@ -365,7 +328,6 @@ export(nnf_tanhshrink)
 export(nnf_threshold)
 export(nnf_threshold_)
 export(nnf_triplet_margin_loss)
-export(nnf_triplet_margin_with_distance_loss)
 export(nnf_unfold)
 export(optim_adadelta)
 export(optim_adagrad)

NEWS.md

@@ -0,0 +1,22 @@
+# tinytorch 0.2.0
+
+## Preparing for CRAN
+
+* First submission target. Package now builds cleanly against 'libtorch' 2.11.0 on Linux and falls back to a stub backend on other Unix platforms so install always succeeds.
+* `DESCRIPTION` rewritten for CRAN: single-quoted software names, angle-bracketed upstream URL, ORCID, and `Cornball AI` as copyright holder matching `LICENSE`.
+* Removed the `glue` import. The package now has a single hard dependency on `Rcpp`.
+* Dropped `R/zzz-compat-ops.R`, a stale set of 38 auto-generated wrappers copied from the 'torch' R package that were never wired up and relied on helpers tinytorch does not provide.
+* Fixed a parse warning in `torch_iinfo()` caused by the `-2147483648L` integer literal.
+* `cuda_synchronize()`, `torch_manual_seed()`, and `torch_scaled_mm()` now actually call libtorch. Previous versions had the C++ implementations in `src/gen-ops.cpp` but never registered them with R, so the R wrappers were effectively stubs. `torch_manual_seed()` now seeds libtorch's global generator (confirmed reproducible across `torch_randn()` calls). `cuda_synchronize()` walks every CUDA device and calls `cudaDeviceSynchronize()` — necessary for correct benchmarking and for surfacing async CUDA errors at a specific line.
+
+## Dispatch and coverage
+
+* Full dispatch table coverage plus autograd and optimizers (#5).
+* Added FP8 dtypes and coverage tests (#8).
+* Bumped bundled libtorch target to 2.11.0 (#7).
+* Exported 38 missing `torch_*` namespace functions (#9).
+
+# tinytorch 0.1.0
+
+* Initial development release. Direct R bindings to 'libtorch' with a
+  'torch'-compatible API.

R/RcppExports.R

@@ -3949,6 +3949,10 @@ C_cuda_empty_cache <- function() {
     .Call(`_tinytorch_C_cuda_empty_cache`)
 }
 
+C_cuda_synchronize <- function() {
+    .Call(`_tinytorch_C_cuda_synchronize`)
+}
+
 C_cuda_mem_info <- function() {
     .Call(`_tinytorch_C_cuda_mem_info`)
 }
@@ -3957,6 +3961,14 @@ C_cuda_memory_stats <- function() {
     .Call(`_tinytorch_C_cuda_memory_stats`)
 }
 
+C_torch_manual_seed <- function(seed) {
+    invisible(.Call(`_tinytorch_C_torch_manual_seed`, seed))
+}
+
+C_torch_scaled_mm <- function(self, mat2, scale_a, scale_b, bias, scale_result, out_dtype, use_fast_accum) {
+    .Call(`_tinytorch_C_torch_scaled_mm`, self, mat2, scale_a, scale_b, bias, scale_result, out_dtype, use_fast_accum)
+}
+
 C_transformer_decoder_layer_step <- function(x_sexp, weights_sexp, self_cache_k_sexp, self_cache_v_sexp, cross_cache_k_sexp, cross_cache_v_sexp, n_head_sexp) {
     .Call(`_tinytorch_C_transformer_decoder_layer_step`, x_sexp, weights_sexp, self_cache_k_sexp, self_cache_v_sexp, cross_cache_k_sexp, cross_cache_v_sexp, n_head_sexp)
 }

R/available.R

@@ -22,9 +22,11 @@ is_available <- function() {
 #' @return The installation path (invisibly).
 #' @export
 #' @examples
-#' \dontrun{
+#' \donttest{
+#' if (torch_is_installed()) {
 #' install_libtorch()
 #' }
+#' }
 install_libtorch <- function(path = "~/.local/lib/libtorch",
                                        version = "2.11.0") {
   path <- normalizePath(path, mustWork = FALSE)

R/convert.R

@@ -2,60 +2,87 @@
 #' @param x A torch_tensor.
 #' @return An R numeric vector, matrix, or array.
 #' @examples
-#' \dontrun{
+#' \donttest{
+#' if (torch_is_installed()) {
 #' x <- torch_tensor(c(1, 2, 3))
 #' as_array(x)
 #' }
+#' }
 #' @export
 as_array <- function(x) {
   C_as_array(x)
 }
 
+#' As.array.torch tensor
+#' @param x Parameter passed to the underlying ATen operator.
+#' @param ... Additional arguments passed to methods.
 #' @examples
-#' \dontrun{
+#' \donttest{
+#' if (torch_is_installed()) {
 #' x <- torch_tensor(matrix(1:6, 2, 3))
 #' as.array(x)
 #' }
+#' }
 #' @export
 as.array.torch_tensor <- function(x, ...) {
   C_as_array(x)
 }
 
+#' As.numeric.torch tensor
+#' @param x Parameter passed to the underlying ATen operator.
+#' @param ... Additional arguments passed to methods.
 #' @examples
-#' \dontrun{
+#' \donttest{
+#' if (torch_is_installed()) {
 #' x <- torch_tensor(c(1, 2, 3))
 #' as.numeric(x)
 #' }
+#' }
 #' @export
 as.numeric.torch_tensor <- function(x, ...) {
   as.numeric(C_as_array(x))
 }
 
+#' As.double.torch tensor
+#' @param x Parameter passed to the underlying ATen operator.
+#' @param ... Additional arguments passed to methods.
 #' @examples
-#' \dontrun{
+#' \donttest{
+#' if (torch_is_installed()) {
 #' x <- torch_tensor(c(1, 2, 3))
 #' as.double(x)
 #' }
+#' }
 #' @export
 as.double.torch_tensor <- function(x, ...) {
   as.double(C_as_array(x))
 }
 
+#' As.integer.torch tensor
+#' @param x Parameter passed to the underlying ATen operator.
+#' @param ... Additional arguments passed to methods.
 #' @examples
-#' \dontrun{
+#' \donttest{
+#' if (torch_is_installed()) {
 #' x <- torch_tensor(c(1, 2, 3))
 #' as.integer(x)
 #' }
+#' }
 #' @export
 as.integer.torch_tensor <- function(x, ...) {
   as.integer(C_as_array(x))
 }
 
+#' As.matrix.torch tensor
+#' @param x Parameter passed to the underlying ATen operator.
+#' @param ... Additional arguments passed to methods.
 #' @examples
-#' \dontrun{
+#' \donttest{
+#' if (torch_is_installed()) {
 #' x <- torch_tensor(matrix(1:6, 2, 3))
 #' as.matrix(x)
 #' }
+#' }
 #' @export
 as.matrix.torch_tensor <- function(x, ...) {
   arr <- C_as_array(x)