chore: Use autogenerated _impl functions instead of .Call() (#2471)

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: krlmlr <[email protected]>
Co-authored-by: Kirill Müller <[email protected]>

Author: Copilot

R/centrality.R

@@ -584,43 +584,14 @@ closeness <- function(
   normalized = FALSE,
   cutoff = -1
 ) {
-  # Argument checks
-  ensure_igraph(graph)
-
-  vids <- as_igraph_vs(graph, vids)
-  mode <- switch(
-    igraph_match_arg(mode),
-    "out" = 1,
-    "in" = 2,
-    "all" = 3,
-    "total" = 3
-  )
-  if (is.null(weights) && "weight" %in% edge_attr_names(graph)) {
-    weights <- E(graph)$weight
-  }
-  if (!is.null(weights) && any(!is.na(weights))) {
-    weights <- as.numeric(weights)
-  } else {
-    weights <- NULL
-  }
-  normalized <- as.logical(normalized)
-  cutoff <- as.numeric(cutoff)
-
-  on.exit(.Call(R_igraph_finalizer))
-  # Function call
-  res <- .Call(
-    R_igraph_closeness_cutoff,
-    graph,
-    vids - 1,
-    mode,
-    weights,
-    normalized,
-    cutoff
+  closeness_cutoff_impl(
+    graph = graph,
+    vids = vids,
+    mode = mode,
+    weights = weights,
+    normalized = normalized,
+    cutoff = cutoff
   )$res
-  if (igraph_opt("add.vertex.names") && is_named(graph)) {
-    names(res) <- V(graph)$name[vids]
-  }
-  res
 }
 
 #' Deprecated version of `closeness()`

R/community.R

@@ -911,36 +911,18 @@ modularity.igraph <- function(
   directed = TRUE,
   ...
 ) {
-  # Argument checks
-  ensure_igraph(x)
   if (
     is.null(membership) || (!is.numeric(membership) && !is.factor(membership))
   ) {
     cli::cli_abort("Membership is not a numerical vector")
   }
-  membership <- as.numeric(membership)
-  if (is.null(weights) && "weight" %in% edge_attr_names(x)) {
-    weights <- E(x)$weight
-  }
-  if (!is.null(weights) && any(!is.na(weights))) {
-    weights <- as.numeric(weights)
-  } else {
-    weights <- NULL
-  }
-  resolution <- as.numeric(resolution)
-  directed <- as.logical(directed)
-
-  on.exit(.Call(R_igraph_finalizer))
-  # Function call
-  res <- .Call(
-    R_igraph_modularity,
-    x,
-    membership - 1,
-    weights,
-    resolution,
-    directed
+  modularity_impl(
+    graph = x,
+    membership = membership,
+    weights = weights,
+    resolution = resolution,
+    directed = directed
   )
-  res
 }
 
 #' @rdname communities
@@ -1784,17 +1766,9 @@ cluster_leiden <- function(
 #' g <- make_graph("Zachary")
 #' comms <- cluster_fluid_communities(g, 2)
 cluster_fluid_communities <- function(graph, no.of.communities) {
-  # Argument checks
-  ensure_igraph(graph)
-
-  no.of.communities <- as.numeric(no.of.communities)
-
-  on.exit(.Call(R_igraph_finalizer))
-  # Function call
-  membership <- .Call(
-    R_igraph_community_fluid_communities,
-    graph,
-    no.of.communities
+  membership <- community_fluid_communities_impl(
+    graph = graph,
+    no_of_communities = no.of.communities
   )
 
   res <- list()

R/flow.R

@@ -434,20 +434,12 @@ min_cut <- function(
         capacity
       )
     } else {
-      res <- .Call(
-        R_igraph_st_mincut,
-        graph,
-        as_igraph_vs(graph, source) - 1,
-        as_igraph_vs(graph, target) - 1,
-        capacity
+      res <- st_mincut_impl(
+        graph = graph,
+        source = source,
+        target = target,
+        capacity = capacity
       )
-      # No need to add +1 here; R_igraph_st_mincut() is autogenerated and
-      # adds +1 already
-      if (igraph_opt("return.vs.es")) {
-        res$cut <- create_es(graph, res$cut)
-        res$partition1 <- create_vs(graph, res$partition1)
-        res$partition2 <- create_vs(graph, res$partition2)
-      }
     }
   }
 

R/games.R

@@ -1073,13 +1073,11 @@ sample_gnm <- function(n, m, directed = FALSE, loops = FALSE) {
   type <- "gnm"
   type1 <- switch(type, "gnp" = 0, "gnm" = 1)
 
-  on.exit(.Call(R_igraph_finalizer))
-  res <- .Call(
-    R_igraph_erdos_renyi_game_gnm,
-    as.numeric(n),
-    as.numeric(m),
-    as.logical(directed),
-    as.logical(loops)
+  res <- erdos_renyi_game_gnm_impl(
+    n = n,
+    m = m,
+    directed = directed,
+    loops = loops
   )
 
   if (igraph_opt("add.params")) {
@@ -1953,16 +1951,14 @@ sample_pref <- function(
     ))
   }
 
-  on.exit(.Call(R_igraph_finalizer))
-  res <- .Call(
-    R_igraph_preference_game,
-    as.numeric(nodes),
-    as.numeric(types),
-    as.double(type.dist),
-    as.logical(fixed.sizes),
-    matrix(as.double(pref.matrix), types, types),
-    as.logical(directed),
-    as.logical(loops)
+  res <- preference_game_impl(
+    nodes = nodes,
+    types = types,
+    type_dist = type.dist,
+    fixed_sizes = fixed.sizes,
+    pref_matrix = pref.matrix,
+    directed = directed,
+    loops = loops
   )
   V(res[[1]])$type <- res[[2]] + 1
   if (igraph_opt("add.params")) {
@@ -2004,15 +2000,13 @@ sample_asym_pref <- function(
     ))
   }
 
-  on.exit(.Call(R_igraph_finalizer))
-  res <- .Call(
-    R_igraph_asymmetric_preference_game,
-    as.numeric(nodes),
-    as.numeric(types),
-    as.numeric(types),
-    matrix(as.double(type.dist.matrix), types, types),
-    matrix(as.double(pref.matrix), types, types),
-    as.logical(loops)
+  res <- asymmetric_preference_game_impl(
+    nodes = nodes,
+    out_types = types,
+    in_types = types,
+    type_dist_matrix = type.dist.matrix,
+    pref_matrix = pref.matrix,
+    loops = loops
   )
   V(res[[1]])$outtype <- res[[2]] + 1
   V(res[[1]])$intype <- res[[3]] + 1

R/hrg.R

@@ -456,34 +456,12 @@ predict_edges <- function(
   num.samples = 10000,
   num.bins = 25
 ) {
-  # Argument checks
-  ensure_igraph(graph)
-  if (is.null(hrg)) {
-    hrg <- list(
-      left = c(),
-      right = c(),
-      prob = c(),
-      edges = c(),
-      vertices = c()
-    )
-  }
-  hrg <- lapply(
-    hrg[c("left", "right", "prob", "edges", "vertices")],
-    as.numeric
-  )
-  start <- as.logical(start)
-  num.samples <- as.numeric(num.samples)
-  num.bins <- as.numeric(num.bins)
-
-  on.exit(.Call(R_igraph_finalizer))
-  # Function call
-  res <- .Call(
-    R_igraph_hrg_predict,
-    graph,
-    hrg,
-    start,
-    num.samples,
-    num.bins
+  res <- hrg_predict_impl(
+    graph = graph,
+    hrg = hrg,
+    start = start,
+    num_samples = num.samples,
+    num_bins = num.bins
   )
   res$edges <- matrix(res$edges, ncol = 2, byrow = TRUE)
   class(res$hrg) <- "igraphHRG"

R/layout.R

@@ -1287,42 +1287,26 @@ layout_with_dh <- function(
   weight.edge.crossings = 1.0 - sqrt(edge_density(graph)),
   weight.node.edge.dist = 0.2 * (1 - edge_density(graph))
 ) {
-  # Argument checks
-  ensure_igraph(graph)
-  if (!is.null(coords)) {
-    coords[] <- as.numeric(coords)
-    use.seed <- TRUE
-  } else {
+  if (is.null(coords)) {
     coords <- matrix(NA_real_, ncol = 2, nrow = 0)
     use.seed <- FALSE
+  } else {
+    use.seed <- TRUE
   }
-  maxiter <- as.numeric(maxiter)
-  fineiter <- as.numeric(fineiter)
-  cool.fact <- as.numeric(cool.fact)
-  weight.node.dist <- as.numeric(weight.node.dist)
-  weight.border <- as.numeric(weight.border)
-  weight.edge.lengths <- as.numeric(weight.edge.lengths)
-  weight.edge.crossings <- as.numeric(weight.edge.crossings)
-  weight.node.edge.dist <- as.numeric(weight.node.edge.dist)
 
-  on.exit(.Call(R_igraph_finalizer))
-  # Function call
-  res <- .Call(
-    R_igraph_layout_davidson_harel,
-    graph,
-    coords,
-    use.seed,
-    maxiter,
-    fineiter,
-    cool.fact,
-    weight.node.dist,
-    weight.border,
-    weight.edge.lengths,
-    weight.edge.crossings,
-    weight.node.edge.dist
+  layout_davidson_harel_impl(
+    graph = graph,
+    res = coords,
+    use_seed = use.seed,
+    maxiter = maxiter,
+    fineiter = fineiter,
+    cool_fact = cool.fact,
+    weight_node_dist = weight.node.dist,
+    weight_border = weight.border,
+    weight_edge_lengths = weight.edge.lengths,
+    weight_edge_crossings = weight.edge.crossings,
+    weight_node_edge_dist = weight.node.edge.dist
   )
-
-  res
 }
 
 
@@ -1596,35 +1580,22 @@ layout_with_gem <- function(
   temp.min = 1 / 10,
   temp.init = sqrt(max(vcount(graph), 1))
 ) {
-  # Argument checks
-  ensure_igraph(graph)
-  if (!is.null(coords)) {
-    coords[] <- as.numeric(coords)
-    use.seed <- TRUE
-  } else {
+  if (is.null(coords)) {
     coords <- matrix(NA_real_, ncol = 2, nrow = 0)
     use.seed <- FALSE
+  } else {
+    use.seed <- TRUE
   }
 
-  maxiter <- as.numeric(maxiter)
-  temp.max <- as.numeric(temp.max)
-  temp.min <- as.numeric(temp.min)
-  temp.init <- as.numeric(temp.init)
-
-  on.exit(.Call(R_igraph_finalizer))
-  # Function call
-  res <- .Call(
-    R_igraph_layout_gem,
-    graph,
-    coords,
-    use.seed,
-    maxiter,
-    temp.max,
-    temp.min,
-    temp.init
+  layout_gem_impl(
+    graph = graph,
+    res = coords,
+    use_seed = use.seed,
+    maxiter = maxiter,
+    temp_max = temp.max,
+    temp_min = temp.min,
+    temp_init = temp.init
   )
-
-  res
 }
 
 
@@ -2304,34 +2275,15 @@ layout_with_sugiyama <- function(
   weights = NULL,
   attributes = c("default", "all", "none")
 ) {
-  # Argument checks
-  ensure_igraph(graph)
-  if (!is.null(layers)) {
-    layers <- as.numeric(layers) - 1
-  }
-  hgap <- as.numeric(hgap)
-  vgap <- as.numeric(vgap)
-  maxiter <- as.numeric(maxiter)
-  if (is.null(weights) && "weight" %in% edge_attr_names(graph)) {
-    weights <- E(graph)$weight
-  }
-  if (!is.null(weights) && any(!is.na(weights))) {
-    weights <- as.numeric(weights)
-  } else {
-    weights <- NULL
-  }
   attributes <- igraph_match_arg(attributes)
 
-  on.exit(.Call(R_igraph_finalizer))
-  # Function call
-  res <- .Call(
-    R_igraph_layout_sugiyama,
-    graph,
-    layers,
-    hgap,
-    vgap,
-    maxiter,
-    weights
+  res <- layout_sugiyama_impl(
+    graph = graph,
+    layers = layers,
+    hgap = hgap,
+    vgap = vgap,
+    maxiter = maxiter,
+    weights = weights
   )
 
   # Flip the y coordinates, more natural this way