@delali/narsil-react-native 0.3.1-next.155 → 0.3.1-next.156

package/cpp/HybridNarsilCoreKeyword.cpp

@@ -0,0 +1,253 @@
+#include "HostMemory.hpp"
+#include "HybridNarsilCoreImpl.hpp"
+
+#include <cerrno>
+#include <cmath>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::narsil {
+
+namespace {
+
+enum KeywordArgument : size_t {
+  ARGUMENT_POOL_DOC_IDS,
+  ARGUMENT_POOL_FREQUENCIES,
+  ARGUMENT_POOL_FIELDS,
+  ARGUMENT_ROW_DOC_IDS,
+  ARGUMENT_ROW_FREQUENCIES,
+  ARGUMENT_ROW_FIELDS,
+  ARGUMENT_SLOTS,
+  ARGUMENT_LISTS,
+  ARGUMENT_LIST_VALUES,
+  ARGUMENT_SLOT_VALUES,
+  ARGUMENT_SEARCHABLE,
+  ARGUMENT_PARTIAL_MARKS,
+  ARGUMENT_NAME_RANKS,
+  ARGUMENT_FIELD_NUMBERS,
+  ARGUMENT_LENGTHS,
+  ARGUMENT_FILTER,
+  ARGUMENT_LIVE,
+  ARGUMENT_REMOVED,
+  ARGUMENT_SETTINGS,
+  ARGUMENT_ORDINALS,
+  ARGUMENT_SCORES,
+  ARGUMENT_MATCHED,
+  ARGUMENT_OUTCOME,
+  ARGUMENT_COUNT
+};
+
+static_assert(ARGUMENT_COUNT == KEYWORD_SCORE_ARGUMENT_COUNT);
+
+enum Setting : size_t {
+  SETTING_SLOTS,
+  SETTING_TERMS,
+  SETTING_CAPACITY,
+  SETTING_TOTAL_DOCUMENTS,
+  SETTING_TERM_MATCH,
+  SETTING_ANCHOR,
+  SETTING_LIMIT,
+  SETTING_MIN_SCORE,
+  SETTING_COLLECT,
+  SETTING_COUNT
+};
+
+enum Outcome : size_t { OUTCOME_COUNT, OUTCOME_TOTAL_MATCHED, OUTCOME_SCORING_PATH };
+
+constexpr uint32_t OUTCOME_MIN_LENGTH = OUTCOME_SCORING_PATH;
+
+template <typename Element>
+struct Elements {
+  Element* data;
+  uint32_t length;
+};
+
+size_t wholeProperty(jsi::Runtime& runtime, const jsi::Object& array, const char* name, const char* what) {
+  jsi::Value value = array.getProperty(runtime, name);
+  if (!value.isNumber()) throwInvalid(std::string(what) + " is not a typed array");
+  double number = value.getNumber();
+  if (!std::isfinite(number) || number < 0 || number > UINT32_MAX || std::floor(number) != number) {
+    throwInvalid(std::string(what) + " is not a typed array");
+  }
+  return static_cast<size_t>(number);
+}
+
+template <typename Element>
+Elements<Element> elementsOf(jsi::Runtime& runtime, const jsi::Value& value, const char* what) {
+  if (!value.isObject()) throwInvalid(std::string(what) + " must be a typed array");
+  jsi::Object array = value.getObject(runtime);
+  if (wholeProperty(runtime, array, "BYTES_PER_ELEMENT", what) != sizeof(Element)) {
+    throwInvalid(std::string(what) + " holds elements of the wrong width");
+  }
+  jsi::Value bufferValue = array.getProperty(runtime, "buffer");
+  if (!bufferValue.isObject()) throwInvalid(std::string(what) + " has no buffer");
+  jsi::Object bufferObject = bufferValue.getObject(runtime);
+  if (!bufferObject.isArrayBuffer(runtime)) throwInvalid(std::string(what) + " has no buffer");
+  jsi::ArrayBuffer buffer = bufferObject.getArrayBuffer(runtime);
+  size_t offset = wholeProperty(runtime, array, "byteOffset", what);
+  size_t length = wholeProperty(runtime, array, "length", what);
+  size_t held = buffer.size(runtime);
+  if (offset > held || length > (held - offset) / sizeof(Element)) {
+    throwInvalid(std::string(what) + " reaches past the end of its buffer");
+  }
+  uint8_t* base = buffer.data(runtime);
+  if (base == nullptr) {
+    if (length > 0) throwInvalid(std::string(what) + " has a detached buffer");
+    return {nullptr, 0};
+  }
+  uint8_t* start = base + offset;
+  if (reinterpret_cast<uintptr_t>(start) % alignof(Element) != 0) throwInvalid(std::string(what) + " is misaligned");
+  return {reinterpret_cast<Element*>(start), static_cast<uint32_t>(length)};
+}
+
+uint32_t wholeCount(double value, const char* what) {
+  if (!(value >= 0) || value > UINT32_MAX || std::floor(value) != value) {
+    throwInvalid(std::string(what) + " must be a whole number from 0 to 4294967295");
+  }
+  return static_cast<uint32_t>(value);
+}
+
+uint32_t shorterOf(uint32_t first, uint32_t second) { return first < second ? first : second; }
+
+void readRows(jsi::Runtime& runtime, const jsi::Value* arguments, narsil_keyword_request& request) {
+  auto poolDocIds = elementsOf<const uint32_t>(runtime, arguments[ARGUMENT_POOL_DOC_IDS], "The pool ordinals");
+  auto poolFrequencies =
+      elementsOf<const uint16_t>(runtime, arguments[ARGUMENT_POOL_FREQUENCIES], "The pool frequencies");
+  auto poolFields = elementsOf<const uint16_t>(runtime, arguments[ARGUMENT_POOL_FIELDS], "The pool fields");
+  auto rowDocIds = elementsOf<const uint32_t>(runtime, arguments[ARGUMENT_ROW_DOC_IDS], "The row ordinals");
+  auto rowFrequencies = elementsOf<const double>(runtime, arguments[ARGUMENT_ROW_FREQUENCIES], "The row frequencies");
+  auto rowFields = elementsOf<const uint16_t>(runtime, arguments[ARGUMENT_ROW_FIELDS], "The row fields");
+  request.pool_doc_ids = poolDocIds.data;
+  request.pool_frequencies = poolFrequencies.data;
+  request.pool_fields = poolFields.data;
+  request.pool_length = shorterOf(poolDocIds.length, shorterOf(poolFrequencies.length, poolFields.length));
+  request.row_doc_ids = rowDocIds.data;
+  request.row_frequencies = rowFrequencies.data;
+  request.row_fields = rowFields.data;
+  request.row_length = shorterOf(rowDocIds.length, shorterOf(rowFrequencies.length, rowFields.length));
+}
+
+void readSlots(jsi::Runtime& runtime, const jsi::Value* arguments, narsil_keyword_request& request) {
+  auto slots = elementsOf<const uint32_t>(runtime, arguments[ARGUMENT_SLOTS], "The slots");
+  auto lists = elementsOf<const uint32_t>(runtime, arguments[ARGUMENT_LISTS], "The lists");
+  auto listValues = elementsOf<const double>(runtime, arguments[ARGUMENT_LIST_VALUES], "The list values");
+  auto slotValues = elementsOf<const double>(runtime, arguments[ARGUMENT_SLOT_VALUES], "The slot values");
+  request.slots = slots.data;
+  request.slot_capacity = slots.length / NARSIL_KEYWORD_SLOT_STRIDE;
+  request.lists = lists.data;
+  request.list_values = listValues.data;
+  request.list_capacity = shorterOf(lists.length / NARSIL_KEYWORD_LIST_STRIDE,
+                                    listValues.length / NARSIL_KEYWORD_LIST_VALUE_STRIDE);
+  request.slot_values = slotValues.data;
+  request.slot_value_capacity = slotValues.length;
+}
+
+void readFields(jsi::Runtime& runtime, const jsi::Value* arguments, narsil_keyword_request& request) {
+  auto searchable = elementsOf<const uint8_t>(runtime, arguments[ARGUMENT_SEARCHABLE], "The searchable fields");
+  auto partialMarks = elementsOf<const uint8_t>(runtime, arguments[ARGUMENT_PARTIAL_MARKS], "The partial fields");
+  auto nameRanks = elementsOf<const uint16_t>(runtime, arguments[ARGUMENT_NAME_RANKS], "The field name ranks");
+  auto numbers = elementsOf<const double>(runtime, arguments[ARGUMENT_FIELD_NUMBERS], "The field numbers");
+  uint32_t count = searchable.length;
+  if (count > NARSIL_KEYWORD_MAX_FIELDS || partialMarks.length != count || nameRanks.length != count ||
+      static_cast<uint64_t>(numbers.length) != static_cast<uint64_t>(count) * NARSIL_KEYWORD_FIELD_NUMBER_COLUMNS) {
+    throwInvalid("The field columns of keywordScore disagree on the field count");
+  }
+  request.field_count = count;
+  request.searchable = searchable.data;
+  request.partial_marks = partialMarks.data;
+  request.name_ranks = nameRanks.data;
+  request.field_numbers = numbers.data;
+}
+
+void readLengths(jsi::Runtime& runtime, const jsi::Value& value, std::vector<narsil_keyword_column>& columns,
+                 uint32_t count) {
+  if (!value.isObject() || !value.getObject(runtime).isArray(runtime)) {
+    throwInvalid("The field lengths must be a list");
+  }
+  jsi::Array list = value.getObject(runtime).getArray(runtime);
+  if (list.size(runtime) != count) throwInvalid("The field lengths hold one entry per field");
+  columns.resize(count);
+  for (uint32_t field = 0; field < count; field++) {
+    jsi::Value column = list.getValueAtIndex(runtime, field);
+    columns[field] = {nullptr, 0};
+    if (column.isNull()) continue;
+    auto lengths = elementsOf<const uint32_t>(runtime, column, "A field length column");
+    columns[field] = {lengths.data, lengths.length};
+  }
+}
+
+void readBitsets(jsi::Runtime& runtime, const jsi::Value* arguments, narsil_keyword_request& request) {
+  request.has_filter = !arguments[ARGUMENT_FILTER].isNull();
+  if (request.has_filter) {
+    auto filter = elementsOf<const uint32_t>(runtime, arguments[ARGUMENT_FILTER], "The filter");
+    request.filter = filter.data;
+    request.filter_words = filter.length;
+  }
+  auto live = elementsOf<const uint32_t>(runtime, arguments[ARGUMENT_LIVE], "The live ordinals");
+  auto removed = elementsOf<const uint32_t>(runtime, arguments[ARGUMENT_REMOVED], "The removed ordinals");
+  request.live = live.data;
+  request.live_words = live.length;
+  request.removed = removed.data;
+  request.removed_words = removed.length;
+}
+
+void readSettings(jsi::Runtime& runtime, const jsi::Value* arguments, narsil_keyword_request& request) {
+  auto settings = elementsOf<const double>(runtime, arguments[ARGUMENT_SETTINGS], "The settings");
+  if (settings.length < SETTING_COUNT) throwInvalid("The settings of keywordScore are too short");
+  const double* values = settings.data;
+  request.terms = values[SETTING_TERMS];
+  request.total_documents = values[SETTING_TOTAL_DOCUMENTS];
+  request.term_match = values[SETTING_TERM_MATCH];
+  request.limit = values[SETTING_LIMIT];
+  request.min_score = values[SETTING_MIN_SCORE];
+  request.collect = values[SETTING_COLLECT] != 0;
+  request.slot_count = wholeCount(values[SETTING_SLOTS], "The slot count");
+  request.capacity = wholeCount(values[SETTING_CAPACITY], "The capacity");
+}
+
+Elements<double> readOutput(jsi::Runtime& runtime, const jsi::Value* arguments, narsil_keyword_output& output) {
+  auto ordinals = elementsOf<int32_t>(runtime, arguments[ARGUMENT_ORDINALS], "The ordinals");
+  auto scores = elementsOf<double>(runtime, arguments[ARGUMENT_SCORES], "The scores");
+  auto matched = elementsOf<uint32_t>(runtime, arguments[ARGUMENT_MATCHED], "The matched ordinals");
+  auto outcome = elementsOf<double>(runtime, arguments[ARGUMENT_OUTCOME], "The outcome");
+  if (outcome.length < OUTCOME_MIN_LENGTH) throwInvalid("The outcome of keywordScore is too short");
+  output.ordinals = ordinals.data;
+  output.scores = scores.data;
+  output.length = shorterOf(ordinals.length, scores.length);
+  output.matched = matched.data;
+  output.matched_words = matched.length;
+  return outcome;
+}
+
+}
+
+jsi::Value HybridNarsilCoreImpl::keywordScore(jsi::Runtime& runtime, const jsi::Value&, const jsi::Value* arguments,
+                                              size_t count) {
+  if (count != ARGUMENT_COUNT) throwInvalid("keywordScore takes twenty-three arguments");
+  narsil_keyword_request request{};
+  narsil_keyword_output output{};
+  readRows(runtime, arguments, request);
+  readSlots(runtime, arguments, request);
+  readBitsets(runtime, arguments, request);
+  readSettings(runtime, arguments, request);
+  Elements<double> outcome = readOutput(runtime, arguments, output);
+  readFields(runtime, arguments, request);
+  RuntimeState& state = stateOf(runtime);
+  readLengths(runtime, arguments[ARGUMENT_LENGTHS], state.keywordLengths, request.field_count);
+  request.lengths = state.keywordLengths.data();
+  if (state.keywordWorkspace == nullptr) {
+    narsil_workspace* created = nullptr;
+    if (narsil_workspace_create(&created) != NARSIL_OK) throwSystemError(ENOMEM, "allocate the keyword workspace", "");
+    state.keywordWorkspace.reset(created);
+  }
+  narsil_status status = narsil_keyword_score(state.keywordWorkspace.get(), &request, &output);
+  outcome.data[OUTCOME_COUNT] = static_cast<double>(output.count);
+  outcome.data[OUTCOME_TOTAL_MATCHED] = static_cast<double>(output.total_matched);
+  if (outcome.length > OUTCOME_SCORING_PATH) {
+    outcome.data[OUTCOME_SCORING_PATH] = static_cast<double>(output.scoring_path);
+  }
+  return jsi::Value(static_cast<double>(status));
+}
+
+}

package/cpp/HybridNarsilCoreMath.cpp

@@ -0,0 +1,47 @@
+#include "HostMemory.hpp"
+#include "HybridNarsilCoreImpl.hpp"
+#include "narsil_math.h"
+
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace margelo::nitro::narsil {
+
+namespace {
+
+double* valuesOf(const MemoryView& view, const char* what, size_t* count) {
+  uint8_t* bytes = bytesWithin(view.buffer, view.byteOffset, view.byteLength, what);
+  size_t length = static_cast<size_t>(view.byteLength);
+  if ((bytes == nullptr && length > 0) || reinterpret_cast<uintptr_t>(bytes) % alignof(double) != 0 ||
+      length % sizeof(double) != 0) {
+    throwInvalid(std::string(what) + " must be a Float64Array");
+  }
+  *count = length / sizeof(double);
+  return reinterpret_cast<double*>(bytes);
+}
+
+}
+
+double HybridNarsilCoreImpl::applyMath(double operation, const MemoryView& first, const MemoryView& second,
+                                       const MemoryView& results) {
+  if (!std::isfinite(operation) || operation < 0 || operation >= NARSIL_MATH_FUNCTION_COUNT ||
+      std::floor(operation) != operation) {
+    throwInvalid("The maths function must be an index from the core's header");
+  }
+  auto function = static_cast<narsil_math_function>(static_cast<int>(operation));
+  size_t firstCount = 0;
+  size_t secondCount = 0;
+  narsil_math_batch batch{};
+  batch.first = valuesOf(first, "The arguments", &firstCount);
+  const double* runs = valuesOf(second, "The second arguments", &secondCount);
+  batch.results = valuesOf(results, "The results", &batch.count);
+  if (firstCount != batch.count || (function == NARSIL_MATH_ATAN2 && secondCount != batch.count)) {
+    throwInvalid("The arguments and the results must hold the same number of values");
+  }
+  batch.second = function == NARSIL_MATH_ATAN2 ? runs : nullptr;
+  return static_cast<double>(narsil_math_apply(function, &batch));
+}
+
+}

package/cpp/core/include/narsil_analysis.h

@@ -0,0 +1,86 @@
+#ifndef NARSIL_ANALYSIS_H
+#define NARSIL_ANALYSIS_H
+
+#include "narsil_core.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NARSIL_ANALYSE_STEM (1U << 0)
+#define NARSIL_ANALYSE_REMOVE_STOP_WORDS (1U << 1)
+#define NARSIL_ANALYSE_REMOVE_DIACRITICS (1U << 2)
+#define NARSIL_ANALYSE_COLLECT_SURFACES (1U << 3)
+#define NARSIL_ANALYSE_SPELLINGS (1U << 4)
+#define NARSIL_ANALYSE_FLAGS                                                                                           \
+  (NARSIL_ANALYSE_STEM | NARSIL_ANALYSE_REMOVE_STOP_WORDS | NARSIL_ANALYSE_REMOVE_DIACRITICS |                         \
+   NARSIL_ANALYSE_COLLECT_SURFACES)
+#define NARSIL_TRANSFORM_FLAGS (NARSIL_ANALYSE_STEM | NARSIL_ANALYSE_REMOVE_DIACRITICS)
+#define NARSIL_NO_SURFACE UINT32_MAX
+#define NARSIL_NO_TERM_SLOT UINT32_MAX
+#define NARSIL_MAX_ANALYSED_UNITS (1U << 30)
+
+typedef struct narsil_analyser narsil_analyser;
+typedef struct narsil_stop_word_set narsil_stop_word_set;
+
+typedef struct {
+  uint32_t position;
+  uint32_t term_offset;
+  uint32_t term_length;
+  uint32_t surface_offset;
+  uint32_t surface_length;
+  uint32_t original_offset;
+  uint32_t original_length;
+  uint32_t term_slot;
+} narsil_token;
+
+typedef struct {
+  const narsil_token *tokens;
+  uint32_t token_count;
+  const uint16_t *units;
+  uint32_t unit_count;
+} narsil_tokens;
+
+typedef struct {
+  uint32_t language;
+  const narsil_stop_word_set *stop_words;
+  uint32_t flags;
+  const uint16_t *text;
+  uint32_t length;
+} narsil_analysis_request;
+
+uint32_t narsil_language_count(void);
+narsil_status narsil_language_lookup(const char *name, size_t length, uint32_t *language);
+const char *narsil_language_name(uint32_t language);
+const char *narsil_language_revision(uint32_t language);
+
+narsil_status narsil_analyser_create(narsil_analyser **analyser);
+void narsil_analyser_destroy(narsil_analyser *analyser);
+
+narsil_status narsil_stop_word_set_create(const uint16_t *units, const uint32_t *offsets, uint32_t count,
+                                          narsil_stop_word_set **set);
+void narsil_stop_word_set_destroy(narsil_stop_word_set *set);
+
+typedef struct {
+  const uint16_t *units;
+  uint32_t length;
+} narsil_term;
+
+narsil_status narsil_analyse(narsil_analyser *analyser, const narsil_analysis_request *request, narsil_tokens *tokens);
+narsil_status narsil_transform(narsil_analyser *analyser, const narsil_analysis_request *request, narsil_term *term);
+typedef struct {
+  const uint16_t *units;
+  const uint32_t *offsets;
+  uint32_t count;
+} narsil_word_list;
+
+narsil_status narsil_language_stop_words(uint32_t language, narsil_word_list *words);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/cpp/core/include/narsil_core.h

@@ -8,7 +8,7 @@
 extern "C" {
 #endif
 
-#define NARSIL_CORE_ABI_VERSION 6
+#define NARSIL_CORE_ABI_VERSION 8
 
 #define NARSIL_GRAPH_HEADER_WORDS 160
 #define NARSIL_STORE_HEADER_WORDS 16

package/cpp/core/include/narsil_keyword.h

@@ -0,0 +1,110 @@
+#ifndef NARSIL_KEYWORD_H
+#define NARSIL_KEYWORD_H
+
+#include "narsil_core.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NARSIL_KEYWORD_TERM_SLOT 0U
+#define NARSIL_KEYWORD_GROUP_SLOT 1U
+#define NARSIL_KEYWORD_PHRASE_SLOT 2U
+
+#define NARSIL_KEYWORD_SLOT_STRIDE 4U
+#define NARSIL_KEYWORD_SLOT_KIND 0U
+#define NARSIL_KEYWORD_SLOT_TERM 1U
+#define NARSIL_KEYWORD_SLOT_LIST_END 2U
+#define NARSIL_KEYWORD_SLOT_VALUE_END 3U
+
+#define NARSIL_KEYWORD_LIST_STRIDE 3U
+#define NARSIL_KEYWORD_LIST_FLAGS 0U
+#define NARSIL_KEYWORD_LIST_START 1U
+#define NARSIL_KEYWORD_LIST_LENGTH 2U
+#define NARSIL_KEYWORD_LIST_FROM_ROWS 1U
+#define NARSIL_KEYWORD_LIST_ORDERED 2U
+
+#define NARSIL_KEYWORD_LIST_VALUE_STRIDE 2U
+#define NARSIL_KEYWORD_LIST_DOCUMENT_FREQUENCY 0U
+#define NARSIL_KEYWORD_LIST_FACTOR 0U
+#define NARSIL_KEYWORD_LIST_PARTIAL_FACTOR 1U
+
+#define NARSIL_KEYWORD_FIELD_BOOSTS 0U
+#define NARSIL_KEYWORD_FIELD_AVERAGE_LENGTHS 1U
+#define NARSIL_KEYWORD_FIELD_K1 2U
+#define NARSIL_KEYWORD_FIELD_B 3U
+#define NARSIL_KEYWORD_FIELD_NUMBER_COLUMNS 4U
+
+#define NARSIL_KEYWORD_SCORED_IN_FULL 0U
+#define NARSIL_KEYWORD_PRUNED 1U
+#define NARSIL_KEYWORD_PRUNED_THEN_FULL 2U
+
+#define NARSIL_KEYWORD_NO_LIMIT (-1.0)
+#define NARSIL_KEYWORD_MAX_FIELDS 65536U
+
+typedef struct {
+  const uint32_t *values;
+  uint32_t length;
+} narsil_keyword_column;
+
+typedef struct {
+  const uint32_t *pool_doc_ids;
+  const uint16_t *pool_frequencies;
+  const uint16_t *pool_fields;
+  uint32_t pool_length;
+  const uint32_t *row_doc_ids;
+  const double *row_frequencies;
+  const uint16_t *row_fields;
+  uint32_t row_length;
+  const uint32_t *slots;
+  uint32_t slot_count;
+  uint32_t slot_capacity;
+  const uint32_t *lists;
+  const double *list_values;
+  uint32_t list_capacity;
+  const double *slot_values;
+  uint32_t slot_value_capacity;
+  uint32_t field_count;
+  const uint8_t *searchable;
+  const uint8_t *partial_marks;
+  const uint16_t *name_ranks;
+  const double *field_numbers;
+  const narsil_keyword_column *lengths;
+  int has_filter;
+  const uint32_t *filter;
+  uint32_t filter_words;
+  const uint32_t *live;
+  uint32_t live_words;
+  const uint32_t *removed;
+  uint32_t removed_words;
+  double terms;
+  uint32_t capacity;
+  double total_documents;
+  double term_match;
+  double limit;
+  double min_score;
+  int collect;
+} narsil_keyword_request;
+
+typedef struct {
+  int32_t *ordinals;
+  double *scores;
+  uint32_t length;
+  uint32_t *matched;
+  uint32_t matched_words;
+  uint32_t count;
+  uint32_t total_matched;
+  uint32_t scoring_path;
+} narsil_keyword_output;
+
+narsil_status narsil_keyword_score(narsil_workspace *workspace, const narsil_keyword_request *request,
+                                   narsil_keyword_output *output);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/cpp/core/include/narsil_math.h

@@ -0,0 +1,36 @@
+#ifndef NARSIL_MATH_H
+#define NARSIL_MATH_H
+
+#include "narsil_core.h"
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+  NARSIL_MATH_LOG = 0,
+  NARSIL_MATH_SIN = 1,
+  NARSIL_MATH_COS = 2,
+  NARSIL_MATH_TAN = 3,
+  NARSIL_MATH_ASIN = 4,
+  NARSIL_MATH_ATAN = 5,
+  NARSIL_MATH_ATAN2 = 6,
+  NARSIL_MATH_FUNCTION_COUNT = 7,
+} narsil_math_function;
+
+typedef struct {
+  const double *first;
+  const double *second;
+  double *results;
+  size_t count;
+} narsil_math_batch;
+
+narsil_status narsil_math_apply(narsil_math_function function, const narsil_math_batch *batch);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif