react-native-executorch 0.5.1 → 0.5.3

package/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/ETModel.mm

@@ -1,249 +0,0 @@
-#import "ETModel.h"
-#include "Utils.hpp"
-#include <executorch/extension/module/module.h>
-#include <executorch/extension/tensor/tensor.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/result.h>
-#include <string>
-
-using namespace ::executorch::extension;
-using namespace ::torch::executor;
-
-@implementation ETModel {
-  std::unique_ptr<Module> _model;
-}
-
-- (NSNumber *)loadModel:(NSString *)filePath {
-  _model = std::make_unique<Module>(filePath.UTF8String);
-  Error err = _model->load();
-  return @((int)err);
-}
-
-- (NSNumber *)loadMethod:(NSString *)methodName {
-  Error err = _model->load_method([methodName UTF8String]);
-  return @((int)err);
-}
-
-- (NSNumber *)loadForward {
-  Error err = _model->load_forward();
-  return @((int)err);
-}
-
-- (NSNumber *)getNumberOfInputs {
-  const auto method_meta = _model->method_meta("forward");
-  if (!method_meta.ok()) {
-    @throw [NSException
-        exceptionWithName:@"get_number_of_inputs_error"
-                   reason:[NSString stringWithFormat:@"%ld",
-                                                     (long)method_meta.error()]
-                 userInfo:nil];
-  }
-
-  return @(method_meta->num_inputs());
-}
-
-- (NSNumber *)getInputType:(NSNumber *)index {
-  const auto method_meta = _model->method_meta("forward");
-  if (!method_meta.ok()) {
-    @throw [NSException
-        exceptionWithName:@"get_input_type_error"
-                   reason:[NSString stringWithFormat:@"%ld",
-                                                     (long)method_meta.error()]
-                 userInfo:nil];
-  }
-
-  const auto input_meta =
-      method_meta->input_tensor_meta([index unsignedLongValue]);
-  if (!input_meta.ok()) {
-    @throw [NSException
-        exceptionWithName:@"get_input_type_error"
-                   reason:[NSString
-                              stringWithFormat:@"%ld", (long)input_meta.error()]
-                 userInfo:nil];
-  }
-
-  return scalarTypeToNSNumber(input_meta->scalar_type());
-};
-
-- (NSArray *)getInputShape:(NSNumber *)index {
-  const auto method_meta = _model->method_meta("forward");
-  if (!method_meta.ok()) {
-    @throw [NSException
-        exceptionWithName:@"get_input_shape_error"
-                   reason:[NSString stringWithFormat:@"%ld",
-                                                     (long)method_meta.error()]
-                 userInfo:nil];
-  }
-
-  const auto input_meta =
-      method_meta->input_tensor_meta([index unsignedLongValue]);
-  if (!input_meta.ok()) {
-    @throw [NSException
-        exceptionWithName:@"get_input_shape_error"
-                   reason:[NSString
-                              stringWithFormat:@"%ld", (long)input_meta.error()]
-                 userInfo:nil];
-  }
-
-  const auto shape = input_meta->sizes();
-  NSMutableArray *nsShape = [[NSMutableArray alloc] init];
-
-  for (int i = 0; i < shape.size(); i++) {
-    [nsShape addObject:@(shape[i])];
-  }
-
-  return [nsShape copy];
-};
-
-- (NSNumber *)getNumberOfOutputs {
-  const auto method_meta = _model->method_meta("forward");
-  if (!method_meta.ok()) {
-    @throw [NSException
-        exceptionWithName:@"get_number_of_outputs_error"
-                   reason:[NSString stringWithFormat:@"%ld",
-                                                     (long)method_meta.error()]
-                 userInfo:nil];
-  }
-
-  return @(method_meta->num_outputs());
-}
-
-- (NSNumber *)getOutputType:(NSNumber *)index {
-  const auto method_meta = _model->method_meta("forward");
-  if (!method_meta.ok()) {
-    @throw [NSException
-        exceptionWithName:@"get_output_type_error"
-                   reason:[NSString stringWithFormat:@"%ld",
-                                                     (long)method_meta.error()]
-                 userInfo:nil];
-  }
-
-  const auto output_meta =
-      method_meta->output_tensor_meta([index unsignedLongValue]);
-  if (!output_meta.ok()) {
-    @throw [NSException
-        exceptionWithName:@"get_output_type_error"
-                   reason:[NSString stringWithFormat:@"%ld",
-                                                     (long)output_meta.error()]
-                 userInfo:nil];
-  }
-
-  return scalarTypeToNSNumber(output_meta->scalar_type());
-};
-
-- (NSArray *)getOutputShape:(NSNumber *)index {
-  const auto method_meta = _model->method_meta("forward");
-  if (!method_meta.ok()) {
-    @throw [NSException
-        exceptionWithName:@"get_output_shape_error"
-                   reason:[NSString stringWithFormat:@"%ld",
-                                                     (long)method_meta.error()]
-                 userInfo:nil];
-  }
-
-  const auto output_meta =
-      method_meta->output_tensor_meta([index unsignedLongValue]);
-  if (!output_meta.ok()) {
-    @throw [NSException
-        exceptionWithName:@"get_output_shape_error"
-                   reason:[NSString stringWithFormat:@"%ld",
-                                                     (long)output_meta.error()]
-                 userInfo:nil];
-  }
-
-  const auto shape = output_meta->sizes();
-  NSMutableArray *nsShape = [[NSMutableArray alloc] init];
-
-  for (int i = 0; i < shape.size(); i++) {
-    [nsShape addObject:@(shape[i])];
-  }
-
-  return [nsShape copy];
-};
-
-/**
- * @brief Processes inputs through the forward pass of the model.
- *
- * This method takes input tensors, their corresponding shapes, and types,
- * and performs a forward pass using _model. It supports both
- * single and multiple inputs.
- *
- * @param inputs NSArray* of inputs where each element is an NSArray
- *               representing the data for a tensor.
- * @param shapes An array of shapes corresponding to the input tensors.
- *               Each element is an NSArray of integers defining the dimensions.
- * @param inputTypes An array of NSNumber objects representing the ScalarType of
- *                   the input tensors
- *
- * @return An NSArray containing the results of the forward pass. Each element
- *         represents the output of the corresponding input.
- *
- * @throws NSException Throws an exception with name "forward_error" if
- *                     an error occurs during input processing or model
- * execution.
- *
- * @warning Ensure that the inputs, shapes, and inputTypes arrays have the
- *          same number of elements. Mismatched sizes can lead to runtime
- *          errors.
- **/
-- (NSArray *)execute:(NSString *)methodName
-              inputs:(NSArray *)inputs
-              shapes:(NSArray *)shapes
-          inputTypes:(NSArray *)inputTypes {
-  std::vector<EValue> inputTensors;
-  std::vector<TensorPtr> inputTensorPtrs;
-
-  for (NSUInteger i = 0; i < [inputTypes count]; i++) {
-    NSArray *inputShapeNSArray = [shapes objectAtIndex:i];
-
-    std::vector<int> inputShape = NSArrayToIntVector(inputShapeNSArray);
-    int inputType = [[inputTypes objectAtIndex:i] intValue];
-
-    NSArray *input = [inputs objectAtIndex:i];
-
-    TensorPtr currentTensor = NSArrayToTensorPtr(input, inputShape, inputType);
-    if (!currentTensor) {
-      throw [NSException
-          exceptionWithName:@"forward_error"
-                     reason:[NSString
-                                stringWithFormat:@"%d", Error::InvalidArgument]
-                   userInfo:nil];
-    }
-
-    // Since pushing back to inputTensors would cast to EValue (forward accepts
-    // a vector of EValues) We also push back to inputTensorPtrs to keep the
-    // underlying tensor alive. inputTensorPtrs vector retains shared ownership
-    // to prevent premature destruction
-    inputTensors.push_back(*currentTensor);
-    inputTensorPtrs.push_back(currentTensor);
-  }
-
-  Result result = _model->execute([methodName UTF8String], inputTensors);
-
-  if (!result.ok()) {
-    throw [NSException
-        exceptionWithName:@"forward_error"
-                   reason:[NSString stringWithFormat:@"%d", result.error()]
-                 userInfo:nil];
-  }
-
-  NSMutableArray *output = [NSMutableArray new];
-  for (int i = 0; i < result->size(); i++) {
-    auto currentResultTensor = result->at(i).toTensor();
-    NSArray *currentOutput = arrayToNsArray(
-        currentResultTensor.const_data_ptr(), currentResultTensor.numel(),
-        currentResultTensor.scalar_type());
-    [output addObject:currentOutput];
-  }
-  return output;
-}
-- (NSArray *)forward:(NSArray *)inputs
-              shapes:(NSArray *)shapes
-          inputTypes:(NSArray *)inputTypes {
-  return [self execute:@"forward"
-                inputs:inputs
-                shapes:shapes
-            inputTypes:inputTypes];
-}
-
-@end

package/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/HuggingFaceTokenizer.h

@@ -1,14 +0,0 @@
-#import <Foundation/Foundation.h>
-
-@interface HuggingFaceTokenizer : NSObject
-
-- (instancetype)initWithTokenizerPath:(NSString *)tokenizerPath;
-- (NSArray<NSNumber *> *)encode:(NSString *)text;
-- (NSString *)decode:(NSArray<NSNumber *> *)tokenIds;
-- (NSString *)decode:(NSArray<NSNumber *> *)tokenIds
-    skipSpecialTokens:(BOOL)skipSpecialTokens;
-- (NSUInteger)getVocabSize;
-- (NSString *)idToToken:(NSInteger)tokenId;
-- (NSInteger)tokenToId:(NSString *)token;
-
-@end

package/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/HuggingFaceTokenizer.mm

@@ -1,80 +0,0 @@
-#import "HuggingFaceTokenizer.h"
-#include <fstream>
-#include <iostream>
-#include <stdexcept>
-#include <string>
-#include <tokenizers-cpp/tokenizers_cpp.h>
-
-std::string loadBytesFromFile(const std::string &path) {
-  std::ifstream fs(path, std::ios::in | std::ios::binary);
-  if (fs.fail()) {
-    throw std::runtime_error("Failed to open tokenizer file");
-  }
-  std::string data;
-  fs.seekg(0, std::ios::end);
-  size_t size = static_cast<size_t>(fs.tellg());
-  fs.seekg(0, std::ios::beg);
-  data.resize(size);
-  fs.read(data.data(), size);
-  return data;
-}
-
-@implementation HuggingFaceTokenizer {
-  std::unique_ptr<tokenizers::Tokenizer> _tokenizer;
-}
-
-- (instancetype)initWithTokenizerPath:(NSString *)tokenizerPath {
-  self = [super init];
-  if (self) {
-    auto blob = loadBytesFromFile([tokenizerPath UTF8String]);
-    _tokenizer = tokenizers::Tokenizer::FromBlobJSON(blob);
-  }
-  return self;
-}
-
-- (NSArray<NSNumber *> *)encode:(NSString *)text {
-  std::vector<int32_t> result = _tokenizer->Encode([text UTF8String]);
-  NSMutableArray<NSNumber *> *encodedResult =
-      [[NSMutableArray alloc] initWithCapacity:result.size()];
-  for (int32_t tokenId : result) {
-    [encodedResult addObject:@(tokenId)];
-  }
-
-  return encodedResult;
-}
-
-- (NSString *)decode:(NSArray<NSNumber *> *)tokenIds {
-  return [self decode:tokenIds skipSpecialTokens:NO];
-}
-
-- (NSString *)decode:(NSArray<NSNumber *> *)tokenIds
-    skipSpecialTokens:(BOOL)skipSpecialTokens {
-  std::vector<int32_t> stdTokenIds;
-  stdTokenIds.reserve([tokenIds count]);
-  for (NSNumber *tokenId in tokenIds) {
-    stdTokenIds.push_back([tokenId intValue]);
-  }
-  std::string decodedString =
-      _tokenizer->Decode(stdTokenIds, skipSpecialTokens);
-  return [NSString stringWithUTF8String:decodedString.c_str()];
-}
-
-- (NSUInteger)getVocabSize {
-  return (NSUInteger)_tokenizer->GetVocabSize();
-}
-
-- (NSString *)idToToken:(NSInteger)tokenId {
-  std::string token = _tokenizer->IdToToken(static_cast<int32_t>(tokenId));
-  return [NSString stringWithUTF8String:token.c_str()];
-}
-
-- (NSInteger)tokenToId:(NSString *)token {
-  std::string stdToken = [token UTF8String];
-  return (NSInteger)_tokenizer->TokenToId(stdToken);
-}
-
-- (void)dealloc {
-  _tokenizer.reset();
-}
-
-@end

package/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/LLaMARunner.h

@@ -1,32 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import <UIKit/UIKit.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-FOUNDATION_EXPORT NSErrorDomain const LLaMARunnerErrorDomain;
-
-NS_SWIFT_NAME(Runner)
-@interface LLaMARunner : NSObject
-
-- (instancetype)initWithModelPath:(NSString *)filePath
-                    tokenizerPath:(NSString *)tokenizerPath;
-- (BOOL)isLoaded;
-- (BOOL)loadWithError:(NSError **)error;
-- (BOOL)generate:(NSString *)prompt
-    withTokenCallback:(nullable void (^)(NSString *))callback
-                error:(NSError **)error;
-- (void)stop;
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-NS_ASSUME_NONNULL_END

package/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/LLaMARunner.mm

@@ -1,95 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import "LLaMARunner.h"
-
-#import "runner.h"
-#import <ExecuTorch/ExecuTorchLog.h>
-
-using namespace ::torch::executor;
-
-NSErrorDomain const LLaMARunnerErrorDomain = @"LLaMARunnerErrorDomain";
-
-@interface LLaMARunner () <ExecuTorchLogSink>
-@end
-
-@implementation LLaMARunner {
-  std::unique_ptr<example::Runner> _runner;
-}
-
-- (instancetype)initWithModelPath:(NSString *)modelPath
-                    tokenizerPath:(NSString *)tokenizerPath {
-  self = [super init];
-  if (self) {
-    [ExecuTorchLog.sharedLog addSink:self];
-    _runner = std::make_unique<example::Runner>(modelPath.UTF8String,
-                                                tokenizerPath.UTF8String);
-  }
-  return self;
-}
-
-- (void)dealloc {
-  [ExecuTorchLog.sharedLog removeSink:self];
-}
-
-- (BOOL)isLoaded {
-  return _runner->is_loaded();
-}
-
-- (BOOL)loadWithError:(NSError **)error {
-  const auto status = _runner->load();
-  if (status != Error::Ok) {
-    if (error) {
-      *error = [NSError errorWithDomain:LLaMARunnerErrorDomain
-                                   code:(NSInteger)status
-                               userInfo:nil];
-    }
-    return NO;
-  }
-  return YES;
-}
-
-- (BOOL)generate:(NSString *)prompt
-    withTokenCallback:(nullable void (^)(NSString *))callback
-                error:(NSError **)error {
-  const auto status = _runner->generate(
-      prompt.UTF8String,
-      [callback](const std::string &token) { callback(@(token.c_str())); });
-  if (status != Error::Ok) {
-    if (error) {
-      *error = [NSError errorWithDomain:LLaMARunnerErrorDomain
-                                   code:(NSInteger)status
-                               userInfo:nil];
-      return NO;
-    }
-  }
-  return YES;
-}
-
-- (void)stop {
-  _runner->stop();
-}
-
-#pragma mark - ExecuTorchLogSink
-
-- (void)logWithLevel:(ExecuTorchLogLevel)level
-           timestamp:(NSTimeInterval)timestamp
-            filename:(NSString *)filename
-                line:(NSUInteger)line
-             message:(NSString *)message {
-  NSUInteger totalSeconds = (NSUInteger)timestamp;
-  NSUInteger hours = (totalSeconds / 3600) % 24;
-  NSUInteger minutes = (totalSeconds / 60) % 60;
-  NSUInteger seconds = totalSeconds % 60;
-  NSUInteger microseconds = (timestamp - totalSeconds) * 1000000;
-  NSLog(@"%c %02lu:%02lu:%02lu.%06lu executorch:%s:%zu] %s", (char)level, hours,
-        minutes, seconds, microseconds, filename.UTF8String, line,
-        message.UTF8String);
-}
-
-@end

package/third-party/ios/ExecutorchLib/ExecutorchLib/InputType.h

@@ -1,12 +0,0 @@
-#ifndef InputType_h
-#define InputType_h
-
-typedef NS_ENUM(NSInteger, InputType) {
-  InputTypeInt8 = 0,
-  InputTypeInt32 = 1,
-  InputTypeInt64 = 2,
-  InputTypeFloat32 = 3,
-  InputTypeFloat64 = 4,
-};
-
-#endif /* InputType_h */

package/third-party/ios/ExecutorchLib/ExecutorchLib/Utils.hpp

@@ -1,217 +0,0 @@
-#ifndef Utils_hpp
-#define Utils_hpp
-
-#include <cstdint>
-#include <executorch/extension/module/module.h>
-#include <executorch/extension/tensor/tensor.h>
-#include <memory>
-#include <span>
-#include <string>
-#include <vector>
-
-#ifdef __OBJC__
-#import <Foundation/Foundation.h>
-#endif
-
-using namespace ::executorch::extension;
-using namespace ::torch::executor;
-
-template <typename T> T getValueFromNSNumber(NSNumber *number) {
-  if constexpr (std::is_same<T, char>::value) {
-    return static_cast<T>([number charValue]); // `charValue` for 8-bit integers
-  } else if constexpr (std::is_same<T, int32_t>::value) {
-    return static_cast<T>([number intValue]); // `intValue` for 32-bit integers
-  } else if constexpr (std::is_same<T, long>::value ||
-                       std::is_same<T, long long>::value) {
-    return static_cast<T>(
-        [number longLongValue]); // Use `longLongValue` for 64-bit integers
-  } else if constexpr (std::is_same<T, float>::value) {
-    return static_cast<T>([number floatValue]);
-  } else if constexpr (std::is_same<T, double>::value) {
-    return static_cast<T>([number doubleValue]);
-  } else {
-    static_assert(std::is_same<T, void>::value,
-                  "Unsupported type for getValueFromNSNumber");
-  }
-}
-
-template <typename T>
-std::unique_ptr<T[]> NSArrayToTypedArray(NSArray *nsArray) {
-  size_t arraySize = [nsArray count];
-
-  std::unique_ptr<T[]> typedArray(new T[arraySize]);
-
-  for (NSUInteger i = 0; i < arraySize; ++i) {
-    NSNumber *number = [nsArray objectAtIndex:i];
-    if ([number isKindOfClass:[NSNumber class]]) {
-      typedArray[i] = getValueFromNSNumber<T>(number);
-    } else {
-      typedArray[i] = T();
-    }
-  }
-  return typedArray;
-}
-
-std::function<void(void *)> getDeleterForScalarType(ScalarType scalarType) {
-  switch (scalarType) {
-  case ScalarType::Char:
-    return [](void *ptr) { delete[] static_cast<char *>(ptr); };
-  case ScalarType::Int:
-    return [](void *ptr) { delete[] static_cast<int32_t *>(ptr); };
-  case ScalarType::Long:
-    return [](void *ptr) { delete[] static_cast<long *>(ptr); };
-  case ScalarType::Float:
-    return [](void *ptr) { delete[] static_cast<float *>(ptr); };
-  case ScalarType::Double:
-    return [](void *ptr) { delete[] static_cast<double *>(ptr); };
-  default:
-    throw std::invalid_argument(
-        "Unsupported ScalarType passed to getDeleterForScalarType!");
-  }
-}
-
-ScalarType intValueToScalarType(int intValue) {
-  // Check if the intValue is within the valid range of ScalarType
-  if (intValue < 0 || intValue >= static_cast<int>(ScalarType::NumOptions)) {
-    throw std::out_of_range("Invalid ScalarType integer value: " +
-                            std::to_string(intValue));
-  }
-  return static_cast<ScalarType>(intValue);
-}
-
-NSNumber *scalarTypeToNSNumber(ScalarType scalarType) {
-  return @(static_cast<int>(scalarType));
-}
-
-NSArray *flattenArray(NSArray *array) {
-  NSMutableArray *flatArray = [NSMutableArray array];
-
-  for (id element in array) {
-    if ([element isKindOfClass:[NSArray class]]) {
-      NSArray *nestedArray = flattenArray(element);
-      [flatArray addObjectsFromArray:nestedArray];
-    } else {
-      [flatArray addObject:element];
-    }
-  }
-
-  return [flatArray copy];
-}
-
-void *NSArrayToVoidArray(NSArray *nsArray, ScalarType inputScalarType,
-                         size_t &outSize) {
-  // This function assumes that the passed array may not be flattened,
-  // that's why we flatten it here
-  NSArray *flattenedArray = flattenArray(nsArray);
-  outSize = [flattenedArray count];
-
-  switch (inputScalarType) {
-  case ScalarType::Char: {
-    auto typedArray = NSArrayToTypedArray<char>(flattenedArray);
-    return typedArray.release();
-  }
-  case ScalarType::Long: {
-    auto typedArray = NSArrayToTypedArray<long>(flattenedArray);
-    return typedArray.release();
-  }
-
-  case ScalarType::Int: {
-    auto typedArray = NSArrayToTypedArray<int>(flattenedArray);
-    return typedArray.release();
-  }
-  case ScalarType::Float: {
-    auto typedArray = NSArrayToTypedArray<float>(flattenedArray);
-    return typedArray.release();
-  }
-  case ScalarType::Double: {
-    auto typedArray = NSArrayToTypedArray<double>(flattenedArray);
-    return typedArray.release();
-  }
-  default:
-    throw std::invalid_argument(
-        "Unsupported ScalarType passed to NSArrayToVoidArray!");
-  }
-}
-
-TensorPtr NSArrayToTensorPtr(NSArray *nsArray, std::vector<int> shape,
-                             int inputType) {
-  ScalarType inputScalarType = intValueToScalarType(inputType);
-  size_t arraySize;
-  void *data = NSArrayToVoidArray(nsArray, inputScalarType, arraySize);
-  std::function<void(void *)> deleter =
-      getDeleterForScalarType(inputScalarType);
-  auto tensor = make_tensor_ptr(shape, data, inputScalarType,
-                                TensorShapeDynamism::DYNAMIC_UNBOUND, deleter);
-
-  return tensor;
-}
-
-template <typename T>
-NSArray *arrayToNSArray(const void *array, ssize_t numel) {
-  const T *typedArray = static_cast<const T *>(array);
-  NSMutableArray *nsArray = [NSMutableArray arrayWithCapacity:numel];
-
-  for (int i = 0; i < numel; ++i) {
-    [nsArray addObject:@(typedArray[i])];
-  }
-
-  return [nsArray copy];
-}
-
-template <typename T>
-NSArray *arrayToNSArray(const std::vector<std::span<const T>> &dataPtrVec) {
-  NSMutableArray *nsArray = [NSMutableArray array];
-  for (const auto &span : dataPtrVec) {
-    NSMutableArray *innerArray = [NSMutableArray arrayWithCapacity:span.size()];
-    for (auto x : span) {
-      [innerArray addObject:@(x)];
-    }
-    [nsArray addObject:[innerArray copy]];
-  }
-  return [nsArray copy];
-}
-
-NSArray *arrayToNsArray(const void *dataPtr, size_t numel,
-                        ScalarType scalarType) {
-  switch (scalarType) {
-  case ScalarType::Char: {
-    NSArray *outputArray = arrayToNSArray<char>(dataPtr, numel);
-    return outputArray;
-  }
-  case ScalarType::Long: {
-    NSArray *outputArray = arrayToNSArray<long>(dataPtr, numel);
-    return outputArray;
-  }
-
-  case ScalarType::Int: {
-    NSArray *outputArray = arrayToNSArray<int>(dataPtr, numel);
-    return outputArray;
-  }
-  case ScalarType::Float: {
-    NSArray *outputArray = arrayToNSArray<float>(dataPtr, numel);
-    return outputArray;
-  }
-  case ScalarType::Double: {
-    NSArray *outputArray = arrayToNSArray<double>(dataPtr, numel);
-    return outputArray;
-  }
-  default:
-    throw std::invalid_argument(
-        "Unsupported ScalarType passed to arrayToNSArray!");
-  }
-}
-
-std::vector<int> NSArrayToIntVector(NSArray *inputArray) {
-  std::vector<int> output;
-  for (NSUInteger i = 0; i < [inputArray count]; ++i) {
-    NSNumber *number = [inputArray objectAtIndex:i];
-    if (number) {
-      output.push_back([number intValue]);
-    } else {
-      output.push_back(0);
-    }
-  }
-  return output;
-}
-
-#endif // Utils_hpp