← back to elixir-nx__nx

Function bodies 219 total

All specs Real LLM only Function bodies
top_k function · cpp · L400-L408 (9 LOC)
torchx/c_src/torchx.cpp
fine::Ok<
    std::tuple<fine::ResourcePtr<TorchTensor>, fine::ResourcePtr<TorchTensor>>>
top_k(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> input, int64_t k) {
  auto result = torch::topk(get_tensor(input), k);
  return fine::Ok(
      std::make_tuple(fine::make_resource<TorchTensor>(std::get<0>(result)),
                      fine::make_resource<TorchTensor>(std::get<1>(result))));
}
flip function · cpp · L411-L416 (6 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
flip(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> input,
     std::vector<int64_t> dims) {
  return tensor_ok(torch::flip(get_tensor(input), vec_to_array_ref(dims)));
}
unfold function · cpp · L419-L424 (6 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
unfold(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> input, int64_t dim,
       int64_t size, int64_t step) {
  return tensor_ok(get_tensor(input).unfold(dim, size, step));
}
put function · cpp · L427-L447 (21 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
put(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> input,
    std::vector<int64_t> indices, fine::ResourcePtr<TorchTensor> source) {

  torch::Tensor output = get_tensor(input).clone();
  torch::Tensor destination = output;

  auto source_shape = get_tensor(source).sizes();

  size_t dim = 0;
  for (dim = 0; dim < indices.size() - 1; dim++) {
    auto start = indices[dim];
    destination = destination.slice(dim, start, start + source_shape[dim]);
  }

  destination.slice(dim, indices[dim], indices[dim] + source_shape[dim])
      .copy_(get_tensor(source));

  return tensor_ok(output);
}
permute function · cpp · L450-L455 (6 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
permute(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> input,
        std::vector<int64_t> permutation) {
  return tensor_ok(get_tensor(input).permute(vec_to_array_ref(permutation)));
}
scalar_tensor function · cpp · L462-L470 (9 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
scalar_tensor(ErlNifEnv *env, torch::Scalar scalar, fine::Atom type_atom,
              std::tuple<int64_t, int64_t> device_tuple) {
  auto type = string2type(type_atom.to_string());
  auto device = tuple_to_device(device_tuple);
  return tensor_ok(
      torch::scalar_tensor(scalar, torch::dtype(type).device(device)));
}
randint function · cpp · L473-L481 (9 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
randint(ErlNifEnv *env, int64_t low, int64_t high, std::vector<int64_t> shape,
        fine::Atom type_atom, std::tuple<int64_t, int64_t> device_tuple) {
  auto type = string2type(type_atom.to_string());
  auto device = tuple_to_device(device_tuple);
  return tensor_ok(torch::randint(low, high, vec_to_array_ref(shape),
                                  torch::dtype(type).device(device)));
}
Repobility — the code-quality scanner for AI-generated software · https://repobility.com
rand function · cpp · L484-L495 (12 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
rand(ErlNifEnv *env, double min, double max, std::vector<int64_t> shape,
     fine::Atom type_atom, std::tuple<int64_t, int64_t> device_tuple) {
  auto type = string2type(type_atom.to_string());
  auto device = tuple_to_device(device_tuple);
  auto result =
      torch::rand(vec_to_array_ref(shape), torch::dtype(type).device(device));
  // Scale from [0, 1) to [min, max)
  result = result * (max - min) + min;
  return tensor_ok(result);
}
normal function · cpp · L498-L507 (10 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
normal(ErlNifEnv *env, double mean, double std, std::vector<int64_t> shape,
       fine::Atom type_atom, std::tuple<int64_t, int64_t> device_tuple) {
  auto type = string2type(type_atom.to_string());
  auto device = tuple_to_device(device_tuple);
  return tensor_ok(torch::normal(mean, std, vec_to_array_ref(shape),
                                 c10::nullopt,
                                 torch::dtype(type).device(device)));
}
arange_5 function · cpp · L512-L520 (9 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
arange_5(ErlNifEnv *env, int64_t start, int64_t end, int64_t step,
         fine::Atom type_atom, std::tuple<int64_t, int64_t> device_tuple) {
  auto type = string2type(type_atom.to_string());
  auto device = tuple_to_device(device_tuple);
  return tensor_ok(torch::arange(
      static_cast<double>(start), static_cast<double>(end),
      static_cast<double>(step), torch::dtype(type).device(device)));
}
arange_6 function · cpp · L521-L532 (12 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
arange_6(ErlNifEnv *env, int64_t start, int64_t end, int64_t step,
         fine::Atom type_atom, std::tuple<int64_t, int64_t> device_tuple,
         std::vector<int64_t> shape) {
  auto type = string2type(type_atom.to_string());
  auto device = tuple_to_device(device_tuple);
  auto result = torch::arange(
      static_cast<double>(start), static_cast<double>(end),
      static_cast<double>(step), torch::dtype(type).device(device));
  return tensor_ok(torch::reshape(result, vec_to_array_ref(shape)));
}
ones function · cpp · L536-L544 (9 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
ones(ErlNifEnv *env, std::vector<int64_t> shape, fine::Atom type_atom,
     std::tuple<int64_t, int64_t> device_tuple) {
  auto type = string2type(type_atom.to_string());
  auto device = tuple_to_device(device_tuple);
  return tensor_ok(
      torch::ones(vec_to_array_ref(shape), torch::dtype(type).device(device)));
}
eye function · cpp · L547-L554 (8 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
eye(ErlNifEnv *env, int64_t m, int64_t n, fine::Atom type_atom,
    std::tuple<int64_t, int64_t> device_tuple) {
  auto type = string2type(type_atom.to_string());
  auto device = tuple_to_device(device_tuple);
  return tensor_ok(torch::eye(m, n, torch::dtype(type).device(device)));
}
full function · cpp · L557-L565 (9 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
full(ErlNifEnv *env, std::vector<int64_t> shape, torch::Scalar scalar,
     fine::Atom type_atom, std::tuple<int64_t, int64_t> device_tuple) {
  auto type = string2type(type_atom.to_string());
  auto device = tuple_to_device(device_tuple);
  return tensor_ok(torch::full(vec_to_array_ref(shape), scalar,
                               torch::dtype(type).device(device)));
}
NAME function · cpp · L574-L578 (5 LOC)
torchx/c_src/torchx.cpp
  fine::Ok<fine::ResourcePtr<TorchTensor>> NAME(                               \
      ErlNifEnv *env, fine::ResourcePtr<TorchTensor> a,                        \
      fine::ResourcePtr<TorchTensor> b) {                                      \
    return tensor_ok(torch::TORCH_OP(get_tensor(a), get_tensor(b)));           \
  }                                                                            \
All rows above produced by Repobility · https://repobility.com
NAME function · cpp · L614-L617 (4 LOC)
torchx/c_src/torchx.cpp
  fine::Ok<fine::ResourcePtr<TorchTensor>> NAME(                               \
      ErlNifEnv *env, fine::ResourcePtr<TorchTensor> a) {                      \
    return tensor_ok(torch::TORCH_OP(get_tensor(a)));                          \
  }                                                                            \
cbrt function · cpp · L651-L659 (9 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
cbrt(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> tensor) {
  auto &t = get_tensor(tensor);
  if (t.scalar_type() == torch::kDouble) {
    return tensor_ok(torch::pow(t, 1.0 / 3));
  } else {
    return tensor_ok(torch::pow(t, 1.0f / 3));
  }
}
conjugate function · cpp · L666-L670 (5 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
conjugate(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> a) {
  at::Tensor conjugated = get_tensor(a).conj();
  return tensor_ok(conjugated.clone(conjugated.suggest_memory_format()));
}
tensordot function · cpp · L679-L724 (46 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
tensordot(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> a,
          fine::ResourcePtr<TorchTensor> b, std::vector<int64_t> axes_a,
          std::vector<int64_t> batch_a, std::vector<int64_t> axes_b,
          std::vector<int64_t> batch_b) {

  bool is_batched = batch_a.size() > 0 || batch_b.size() > 0;

  torch::Tensor result;

  if (is_batched) {
    // Handle batched tensordot using vmap/BatchDim
    std::vector<at::BatchDim> batch_dims_a, batch_dims_b;
    int64_t vmap_level = 0;

    for (auto dim : batch_a) {
      batch_dims_a.push_back(at::BatchDim(vmap_level++, dim));
    }
    torch::Tensor batched_a = at::makeBatched(
        get_tensor(a), at::BatchDims(batch_dims_a.begin(), batch_dims_a.end()));

    vmap_level = 0;
    for (auto dim : batch_b) {
      batch_dims_b.push_back(at::BatchDim(vmap_level++, dim));
    }
    torch::Tensor batched_b = at::makeBatched(
        get_tensor(b), at::BatchDims(batch_dims_b.begin(), batch_dims_
matmul function · cpp · L727-L732 (6 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
matmul(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> a,
       fine::ResourcePtr<TorchTensor> b) {
  return tensor_ok(torch::matmul(get_tensor(a), get_tensor(b)));
}
pad function · cpp · L735-L743 (9 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
pad(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> tensor,
    fine::ResourcePtr<TorchTensor> constant, std::vector<int64_t> config) {
  TORCH_CATCH_ERROR(tensor_ok(torch::constant_pad_nd(
                        get_tensor(tensor), vec_to_array_ref(config),
                        get_tensor(constant).item())),
                    "Pad operation");
}
triangular_solve function · cpp · L746-L763 (18 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
triangular_solve(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> a,
                 fine::ResourcePtr<TorchTensor> b, bool transpose, bool upper) {
  TORCH_CATCH_ERROR(
      [&]() {
        auto ts_a = get_tensor(a);
        if (transpose) {
          auto num_dims = ts_a.dim();
          ts_a = torch::transpose(ts_a, num_dims - 2, num_dims - 1);
          upper = !upper;
        }
        torch::Tensor result = torch::linalg_solve_triangular(
            ts_a, get_tensor(b), upper, true, false);
        return tensor_ok(result);
      }(),
      "Triangular solve");
}
TORCH_CATCH_ERROR function · cpp · L750-L761 (12 LOC)
torchx/c_src/torchx.cpp
  TORCH_CATCH_ERROR(
      [&]() {
        auto ts_a = get_tensor(a);
        if (transpose) {
          auto num_dims = ts_a.dim();
          ts_a = torch::transpose(ts_a, num_dims - 2, num_dims - 1);
          upper = !upper;
        }
        torch::Tensor result = torch::linalg_solve_triangular(
            ts_a, get_tensor(b), upper, true, false);
        return tensor_ok(result);
      }(),
Methodology: Repobility · https://repobility.com/research/state-of-ai-code-2026/
determinant function · cpp · L766-L770 (5 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
determinant(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t) {
  return tensor_ok(get_tensor(t).det());
}
sort function · cpp · L773-L781 (9 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>> sort(ErlNifEnv *env,
                                              fine::ResourcePtr<TorchTensor> t,
                                              bool stable, int64_t axis,
                                              bool descending) {
  std::tuple<torch::Tensor, torch::Tensor> result =
      get_tensor(t).sort(stable, axis, descending);
  return tensor_ok(std::get<0>(result));
}
clip function · cpp · L784-L790 (7 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
clip(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t,
     fine::ResourcePtr<TorchTensor> min, fine::ResourcePtr<TorchTensor> max) {
  return tensor_ok(
      torch::clip(get_tensor(t), get_tensor(min), get_tensor(max)));
}
where function · cpp · L793-L800 (8 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
where(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> pred,
      fine::ResourcePtr<TorchTensor> on_true,
      fine::ResourcePtr<TorchTensor> on_false) {
  return tensor_ok(torch::where(get_tensor(pred), get_tensor(on_true),
                                get_tensor(on_false)));
}
sum function · cpp · L803-L809 (7 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>> sum(ErlNifEnv *env,
                                             fine::ResourcePtr<TorchTensor> t,
                                             std::vector<int64_t> dims,
                                             bool keep_dim) {
  return tensor_ok(torch::sum(get_tensor(t), vec_to_array_ref(dims), keep_dim));
}
product_1 function · cpp · L814-L817 (4 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
product_1(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t) {
  return tensor_ok(torch::prod(get_tensor(t)));
}
product_3 function · cpp · L818-L823 (6 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
product_3(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t, int64_t dim,
          bool keep_dim) {
  return tensor_ok(torch::prod(get_tensor(t), dim, keep_dim));
}
argmax function · cpp · L827-L836 (10 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
argmax(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t, int64_t dim,
       bool keep_dim) {
  if (dim == -1) {
    return tensor_ok(torch::argmax(get_tensor(t)));
  } else {
    return tensor_ok(torch::argmax(get_tensor(t), dim, keep_dim));
  }
}
Source: Repobility analyzer · https://repobility.com
argmin function · cpp · L839-L848 (10 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
argmin(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t, int64_t dim,
       bool keep_dim) {
  if (dim == -1) {
    return tensor_ok(torch::argmin(get_tensor(t)));
  } else {
    return tensor_ok(torch::argmin(get_tensor(t), dim, keep_dim));
  }
}
fft function · cpp · L851-L856 (6 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
fft(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> tensor, int64_t length,
    int64_t axis) {
  return tensor_ok(torch::fft::fft(get_tensor(tensor), length, axis));
}
ifft function · cpp · L859-L864 (6 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
ifft(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> tensor, int64_t length,
     int64_t axis) {
  return tensor_ok(torch::fft::ifft(get_tensor(tensor), length, axis));
}
fft2 function · cpp · L867-L873 (7 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
fft2(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> tensor,
     std::vector<int64_t> lengths, std::vector<int64_t> axes) {
  return tensor_ok(torch::fft::fft2(
      get_tensor(tensor), vec_to_array_ref(lengths), vec_to_array_ref(axes)));
}
ifft2 function · cpp · L876-L882 (7 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
ifft2(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> tensor,
      std::vector<int64_t> lengths, std::vector<int64_t> axes) {
  return tensor_ok(torch::fft::ifft2(
      get_tensor(tensor), vec_to_array_ref(lengths), vec_to_array_ref(axes)));
}
all_1 function · cpp · L887-L890 (4 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
all_1(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t) {
  return tensor_ok(torch::all(get_tensor(t)));
}
all_3 function · cpp · L891-L896 (6 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>> all_3(ErlNifEnv *env,
                                               fine::ResourcePtr<TorchTensor> t,
                                               int64_t axis, bool keep_dim) {
  return tensor_ok(torch::all(get_tensor(t), axis, keep_dim));
}
any_1 function · cpp · L902-L905 (4 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
any_1(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t) {
  return tensor_ok(torch::any(get_tensor(t)));
}
Repobility — the code-quality scanner for AI-generated software · https://repobility.com
any_3 function · cpp · L906-L911 (6 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>> any_3(ErlNifEnv *env,
                                               fine::ResourcePtr<TorchTensor> t,
                                               int64_t axis, bool keep_dim) {
  return tensor_ok(torch::any(get_tensor(t), axis, keep_dim));
}
all_close function · cpp · L915-L924 (10 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
all_close(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> a,
          fine::ResourcePtr<TorchTensor> b, double rtol, double atol,
          bool equal_nan) {
  bool result =
      torch::allclose(get_tensor(a), get_tensor(b), rtol, atol, equal_nan);
  auto init_opts = torch::device(torch::kCPU).dtype(torch::kBool);
  return tensor_ok(torch::scalar_tensor(result, init_opts));
}
cumulative_sum function · cpp · L927-L931 (5 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
cumulative_sum(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t, int64_t axis) {
  return tensor_ok(torch::cumsum(get_tensor(t), axis));
}
cumulative_product function · cpp · L934-L939 (6 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
cumulative_product(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t,
                   int64_t axis) {
  return tensor_ok(torch::cumprod(get_tensor(t), axis));
}
cumulative_min function · cpp · L942-L948 (7 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
cumulative_min(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t, int64_t axis) {
  const std::tuple<torch::Tensor, torch::Tensor> &tt =
      torch::cummin(get_tensor(t), axis);
  return tensor_ok(std::get<0>(tt));
}
cumulative_max function · cpp · L951-L957 (7 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
cumulative_max(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t, int64_t axis) {
  const std::tuple<torch::Tensor, torch::Tensor> &tt =
      torch::cummax(get_tensor(t), axis);
  return tensor_ok(std::get<0>(tt));
}
cholesky_1 function · cpp · L962-L965 (4 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
cholesky_1(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t) {
  return tensor_ok(torch::cholesky(get_tensor(t)));
}
cholesky_2 function · cpp · L966-L973 (8 LOC)
torchx/c_src/torchx.cpp
fine::Ok<fine::ResourcePtr<TorchTensor>>
cholesky_2(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t, bool upper) {
  if (upper) {
    return tensor_ok(torch::cholesky(get_tensor(t)).mH());
  }
  return tensor_ok(torch::cholesky(get_tensor(t)));
}
All rows above produced by Repobility · https://repobility.com
qr_1 function · cpp · L979-L997 (19 LOC)
torchx/c_src/torchx.cpp
fine::Ok<
    std::tuple<fine::ResourcePtr<TorchTensor>, fine::ResourcePtr<TorchTensor>>>
qr_1(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t) {
  try {
    auto result = torch::linalg_qr(get_tensor(t), "reduced");
    return fine::Ok(
        std::make_tuple(fine::make_resource<TorchTensor>(std::get<0>(result)),
                        fine::make_resource<TorchTensor>(std::get<1>(result))));
  } catch (const c10::Error &e) {
    throw std::runtime_error(std::string("QR decomposition") +
                             " failed: " + e.what());
  } catch (const std::exception &e) {
    throw std::runtime_error(std::string("QR decomposition") +
                             " failed: " + e.what());
  } catch (...) {
    throw std::runtime_error(std::string("QR decomposition") +
                             " failed with unknown error");
  }
}
qr_2 function · cpp · L998-L1018 (21 LOC)
torchx/c_src/torchx.cpp
fine::Ok<
    std::tuple<fine::ResourcePtr<TorchTensor>, fine::ResourcePtr<TorchTensor>>>
qr_2(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t, bool reduced) {
  try {
    auto result =
        torch::linalg_qr(get_tensor(t), reduced ? "reduced" : "complete");
    return fine::Ok(
        std::make_tuple(fine::make_resource<TorchTensor>(std::get<0>(result)),
                        fine::make_resource<TorchTensor>(std::get<1>(result))));
  } catch (const c10::Error &e) {
    throw std::runtime_error(std::string("QR decomposition") +
                             " failed: " + e.what());
  } catch (const std::exception &e) {
    throw std::runtime_error(std::string("QR decomposition") +
                             " failed: " + e.what());
  } catch (...) {
    throw std::runtime_error(std::string("QR decomposition") +
                             " failed with unknown error");
  }
}
svd_1 function · cpp · L1024-L1044 (21 LOC)
torchx/c_src/torchx.cpp
fine::Ok<
    std::tuple<fine::ResourcePtr<TorchTensor>, fine::ResourcePtr<TorchTensor>,
               fine::ResourcePtr<TorchTensor>>>
svd_1(ErlNifEnv *env, fine::ResourcePtr<TorchTensor> t) {
  try {
    auto result = torch::linalg_svd(get_tensor(t), true);
    return fine::Ok(
        std::make_tuple(fine::make_resource<TorchTensor>(std::get<0>(result)),
                        fine::make_resource<TorchTensor>(std::get<1>(result)),
                        fine::make_resource<TorchTensor>(std::get<2>(result))));
  } catch (const c10::Error &e) {
    throw std::runtime_error(std::string("SVD decomposition") +
                             " failed: " + e.what());
  } catch (const std::exception &e) {
    throw std::runtime_error(std::string("SVD decomposition") +
                             " failed: " + e.what());
  } catch (...) {
    throw std::runtime_error(std::string("SVD decomposition") +
                             " failed with unknown error");
  }
}
‹ prevpage 4 / 5next ›