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

package/cpp/core/src/languages/substitutions.c

@@ -0,0 +1,131 @@
+#include "../analysis/normalise.h"
+#include "../analysis/text.h"
+#include "rules.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define COUNT_OF(array) (sizeof(array) / sizeof((array)[0]))
+
+#define DELETE_UNIT(first, last) {(first), (last), 0, {0, 0}}
+#define REPLACE_UNIT(first, last, unit) {(first), (last), 1, {(unit), 0}}
+
+static const narsil_unit_substitution dagbani_substitutions[] = {
+    REPLACE_UNIT(0x03B5, 0x03B5, 0x025B),
+    REPLACE_UNIT(0x0511, 0x0511, 0x025B),
+};
+
+static const narsil_unit_substitution ewe_substitutions[] = {
+    REPLACE_UNIT(0x00F0, 0x00F0, 0x0256),
+};
+
+static const narsil_unit_substitution german_substitutions[] = {
+    {0x00DF, 0x00DF, 2, {0x0073, 0x0073}},
+};
+
+static const narsil_unit_substitution guarani_substitutions[] = {
+    REPLACE_UNIT(0xA78C, 0xA78C, 0x0027),
+};
+
+static const narsil_unit_substitution hebrew_substitutions[] = {
+    DELETE_UNIT(0x0591, 0x05C7),
+};
+
+static const narsil_unit_substitution persian_substitutions[] = {
+    REPLACE_UNIT(0x064A, 0x064A, 0x06CC), REPLACE_UNIT(0x0649, 0x0649, 0x06CC), REPLACE_UNIT(0x0643, 0x0643, 0x06A9),
+    DELETE_UNIT(0x0640, 0x0640),          DELETE_UNIT(0x064B, 0x0652),
+};
+
+static const narsil_unit_substitution romanian_substitutions[] = {
+    REPLACE_UNIT(0x015F, 0x015F, 0x0219),
+    REPLACE_UNIT(0x0163, 0x0163, 0x021B),
+};
+
+static const narsil_unit_substitution serbian_substitutions[] = {
+    REPLACE_UNIT(0x0430, 0x0430, 0x0061),  REPLACE_UNIT(0x0431, 0x0431, 0x0062), REPLACE_UNIT(0x0432, 0x0432, 0x0076),
+    REPLACE_UNIT(0x0433, 0x0433, 0x0067),  REPLACE_UNIT(0x0434, 0x0434, 0x0064), REPLACE_UNIT(0x0435, 0x0435, 0x0065),
+    REPLACE_UNIT(0x0436, 0x0436, 0x017E),  REPLACE_UNIT(0x0437, 0x0437, 0x007A), REPLACE_UNIT(0x0438, 0x0438, 0x0069),
+    REPLACE_UNIT(0x043A, 0x043A, 0x006B),  REPLACE_UNIT(0x043B, 0x043B, 0x006C), REPLACE_UNIT(0x043C, 0x043C, 0x006D),
+    REPLACE_UNIT(0x043D, 0x043D, 0x006E),  REPLACE_UNIT(0x043E, 0x043E, 0x006F), REPLACE_UNIT(0x043F, 0x043F, 0x0070),
+    REPLACE_UNIT(0x0440, 0x0440, 0x0072),  REPLACE_UNIT(0x0441, 0x0441, 0x0073), REPLACE_UNIT(0x0442, 0x0442, 0x0074),
+    REPLACE_UNIT(0x0443, 0x0443, 0x0075),  REPLACE_UNIT(0x0444, 0x0444, 0x0066), REPLACE_UNIT(0x0445, 0x0445, 0x0068),
+    REPLACE_UNIT(0x0446, 0x0446, 0x0063),  REPLACE_UNIT(0x0447, 0x0447, 0x010D), REPLACE_UNIT(0x0448, 0x0448, 0x0161),
+    REPLACE_UNIT(0x0452, 0x0452, 0x0111),  REPLACE_UNIT(0x0458, 0x0458, 0x006A), {0x0459, 0x0459, 2, {0x006C, 0x006A}},
+    {0x045A, 0x045A, 2, {0x006E, 0x006A}}, REPLACE_UNIT(0x045B, 0x045B, 0x0107), {0x045F, 0x045F, 2, {0x0064, 0x017E}},
+};
+
+static const narsil_unit_substitution sinhala_substitutions[] = {
+    DELETE_UNIT(0x200D, 0x200D),
+};
+
+static const narsil_unit_substitution telugu_substitutions[] = {
+    DELETE_UNIT(0x200C, 0x200C),
+};
+
+static const narsil_unit_substitution twi_substitutions[] = {
+    REPLACE_UNIT(0x03B5, 0x03B5, 0x025B),
+    REPLACE_UNIT(0x037B, 0x037B, 0x0254),
+    REPLACE_UNIT(0x2184, 0x2184, 0x0254),
+    REPLACE_UNIT(0x05DB, 0x05DB, 0x0254),
+};
+
+int narsil_dagbani_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                             narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, dagbani_substitutions, COUNT_OF(dagbani_substitutions), out);
+}
+
+int narsil_ewe_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, ewe_substitutions, COUNT_OF(ewe_substitutions), out);
+}
+
+int narsil_german_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, german_substitutions, COUNT_OF(german_substitutions), out);
+}
+
+int narsil_guarani_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                             narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, guarani_substitutions, COUNT_OF(guarani_substitutions), out);
+}
+
+int narsil_hebrew_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, hebrew_substitutions, COUNT_OF(hebrew_substitutions), out);
+}
+
+int narsil_persian_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                             narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, persian_substitutions, COUNT_OF(persian_substitutions), out);
+}
+
+int narsil_romanian_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                              narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, romanian_substitutions, COUNT_OF(romanian_substitutions), out);
+}
+
+int narsil_serbian_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                             narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, serbian_substitutions, COUNT_OF(serbian_substitutions), out);
+}
+
+int narsil_sinhala_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                             narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, sinhala_substitutions, COUNT_OF(sinhala_substitutions), out);
+}
+
+int narsil_telugu_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, telugu_substitutions, COUNT_OF(telugu_substitutions), out);
+}
+
+int narsil_twi_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  return narsil_substitute_units(units, length, twi_substitutions, COUNT_OF(twi_substitutions), out);
+}

package/cpp/core/src/languages/swahili_stemmer.c

@@ -0,0 +1,85 @@
+#include "../analysis/normalise.h"
+#include "../analysis/text.h"
+#include "rules.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#define MIN_STEMMED_UNITS 4U
+#define MIN_REMAINING_UNITS 3U
+#define COUNT_OF(array) (sizeof(array) / sizeof((array)[0]))
+
+static const uint16_t *const subject_prefixes[] = {u"ni", u"tu", u"wa", u"vi", u"zi", u"li", u"ya", u"ku"};
+static const uint16_t *const short_subject_prefixes[] = {u"u", u"a", u"i", u"m"};
+static const uint16_t *const tense_markers[] = {u"na", u"li", u"ta", u"me", u"ki"};
+static const uint16_t *const relative_markers[] = {u"cho", u"vyo", u"ye", u"zo", u"lo", u"yo", u"ko", u"po", u"mo"};
+static const uint16_t *const negative_prefixes[] = {u"ha", u"si"};
+static const uint16_t *const noun_class_prefixes[] = {u"wa", u"mi", u"ki", u"vi", u"ma"};
+static const uint16_t *const short_noun_prefixes[] = {u"m", u"u"};
+static const uint16_t *const long_suffixes[] = {u"isha", u"ika", u"ana", u"iwa", u"ewa",
+                                                u"aje",  u"ane", u"eni", u"ini"};
+static const uint16_t *const short_suffixes[] = {u"wa", u"ia", u"ea"};
+static const uint16_t *const final_vowels[] = {u"a", u"i", u"e", u"u"};
+
+typedef struct {
+  const uint16_t *units;
+  size_t length;
+} word_view;
+
+static int remove_prefix(word_view *word, const uint16_t *const *prefixes, size_t prefix_count) {
+  for (size_t i = 0; i < prefix_count; i++) {
+    size_t length = narsil_rule_length(prefixes[i]);
+    if (length <= word->length && word->length - length >= MIN_REMAINING_UNITS &&
+        memcmp(word->units, prefixes[i], length * sizeof(uint16_t)) == 0) {
+      word->units += length;
+      word->length -= length;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static int remove_suffix(word_view *word, const uint16_t *const *suffixes, size_t suffix_count) {
+  for (size_t i = 0; i < suffix_count; i++) {
+    size_t length = narsil_rule_length(suffixes[i]);
+    if (length <= word->length && word->length - length >= MIN_REMAINING_UNITS &&
+        memcmp(word->units + (word->length - length), suffixes[i], length * sizeof(uint16_t)) == 0) {
+      word->length -= length;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static void remove_prefixes(word_view *word) {
+  size_t original_length = word->length;
+  remove_prefix(word, negative_prefixes, COUNT_OF(negative_prefixes));
+  int subject_removed = remove_prefix(word, subject_prefixes, COUNT_OF(subject_prefixes));
+  if (!subject_removed) {
+    subject_removed = remove_prefix(word, short_subject_prefixes, COUNT_OF(short_subject_prefixes));
+  }
+  if (subject_removed) {
+    remove_prefix(word, tense_markers, COUNT_OF(tense_markers));
+    remove_prefix(word, relative_markers, COUNT_OF(relative_markers));
+    return;
+  }
+  remove_prefix(word, noun_class_prefixes, COUNT_OF(noun_class_prefixes));
+  if (word->length == original_length) { remove_prefix(word, short_noun_prefixes, COUNT_OF(short_noun_prefixes)); }
+}
+
+static void remove_suffixes(word_view *word) {
+  if (remove_suffix(word, long_suffixes, COUNT_OF(long_suffixes))) { return; }
+  if (remove_suffix(word, short_suffixes, COUNT_OF(short_suffixes))) { return; }
+  remove_suffix(word, final_vowels, COUNT_OF(final_vowels));
+}
+
+int narsil_swahili_stem(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  word_view word = {units, length};
+  if (length >= MIN_STEMMED_UNITS) {
+    remove_prefixes(&word);
+    remove_suffixes(&word);
+  }
+  return narsil_text_assign(out, word.units, word.length);
+}

package/cpp/core/src/languages/ukrainian_stemmer.c

@@ -0,0 +1,168 @@
+#include "../analysis/normalise.h"
+#include "../analysis/text.h"
+#include "rules.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#define NO_MATCH SIZE_MAX
+#define LIST_OF(array) {(array), sizeof(array) / sizeof((array)[0])}
+#define CYRILLIC_A 0x0430U
+#define CYRILLIC_YA 0x044FU
+
+typedef struct {
+  const uint16_t *units;
+  size_t length;
+  size_t rv;
+  size_t r2;
+} ukrainian_word;
+
+typedef struct {
+  const uint16_t *const *suffixes;
+  size_t count;
+} suffix_list;
+
+static const uint16_t vowels[] = {0x0430, 0x0435, 0x0438, 0x043E, 0x0443, 0x044E, 0x044F, 0x0456, 0x0457, 0x0454};
+
+static const uint16_t *const perfective_gerund_after_a_suffixes[] = {u"вшись", u"вши", u"в"};
+static const uint16_t *const perfective_gerund_suffixes[] = {u"івшись", u"ивши", u"ів"};
+static const uint16_t *const reflexive_suffixes[] = {u"ся", u"сь"};
+static const uint16_t *const adjective_suffixes[] = {
+    u"ими", u"ого", u"ому", u"ій", u"ий", u"їй", u"ою", u"ее", u"іе", u"іє", u"ие", u"ої", u"їй",
+    u"ем",  u"ім",  u"ом",  u"им", u"их", u"іх", u"ую", u"юю", u"ая", u"яя", u"ое", u"еє",
+};
+static const uint16_t *const participle_after_a_suffixes[] = {u"ем", u"нн", u"вш", u"ющ", u"щ"};
+static const uint16_t *const participle_suffixes[] = {u"івш", u"ивш", u"уюч", u"ующ"};
+static const uint16_t *const verb_after_a_suffixes[] = {
+    u"ете", u"йте", u"ешь", u"нно", u"ла", u"на", u"ли", u"ем", u"ло",
+    u"но",  u"ет",  u"ют",  u"ни",  u"ть", u"й",  u"л",  u"н",
+};
+static const uint16_t *const verb_suffixes[] = {
+    u"ейте", u"уйте", u"ують", u"ила", u"ила", u"ена", u"іте", u"ите", u"или", u"ило", u"ено", u"ять", u"ить",
+    u"іть",  u"ішь",  u"ей",   u"уй",  u"ив",  u"ил",  u"ім",  u"им",  u"ен",  u"ує",  u"ую",  u"ю",
+};
+static const uint16_t *const noun_suffixes[] = {
+    u"іями", u"ями", u"іям", u"ієм", u"ією", u"ами", u"еві", u"ові", u"ів", u"їв", u"ій", u"ей", u"ем",
+    u"єм",   u"єю",  u"ов",  u"ой",  u"ом",  u"ою",  u"ію",  u"ью",  u"ія", u"ья", u"ям", u"ях", u"ах",
+    u"ам",   u"а",   u"е",   u"є",   u"і",   u"ї",   u"и",   u"й",   u"о",  u"у",  u"ь",  u"ю",  u"я",
+};
+static const uint16_t *const derivational_suffixes[] = {u"ість", u"ость", u"іст", u"ост"};
+
+static const suffix_list perfective_gerund_after_a = LIST_OF(perfective_gerund_after_a_suffixes);
+static const suffix_list perfective_gerund = LIST_OF(perfective_gerund_suffixes);
+static const suffix_list reflexive = LIST_OF(reflexive_suffixes);
+static const suffix_list adjective = LIST_OF(adjective_suffixes);
+static const suffix_list participle_after_a = LIST_OF(participle_after_a_suffixes);
+static const suffix_list participle = LIST_OF(participle_suffixes);
+static const suffix_list verb_after_a = LIST_OF(verb_after_a_suffixes);
+static const suffix_list verb = LIST_OF(verb_suffixes);
+static const suffix_list noun = LIST_OF(noun_suffixes);
+static const suffix_list derivational = LIST_OF(derivational_suffixes);
+
+static int is_vowel(uint16_t unit) {
+  for (size_t i = 0; i < sizeof(vowels) / sizeof(vowels[0]); i++) {
+    if (vowels[i] == unit) { return 1; }
+  }
+  return 0;
+}
+
+static size_t vowel_then_consonant_after(const ukrainian_word *word, size_t from) {
+  for (size_t i = from; i < word->length; i++) {
+    if (!is_vowel(word->units[i]) && is_vowel(word->units[i - 1])) { return i + 1; }
+  }
+  return word->length;
+}
+
+static ukrainian_word regions_of(const uint16_t *units, size_t length) {
+  ukrainian_word word = {units, length, length, length};
+  for (size_t i = 0; i < length; i++) {
+    if (is_vowel(units[i])) {
+      word.rv = i + 1;
+      break;
+    }
+  }
+  size_t region_one = vowel_then_consonant_after(&word, 1);
+  word.r2 = vowel_then_consonant_after(&word, region_one + 1);
+  return word;
+}
+
+static size_t strip(const ukrainian_word *word, size_t length, const uint16_t *suffix, size_t region) {
+  size_t suffix_length = narsil_rule_length(suffix);
+  if (suffix_length > length || length - suffix_length < region) { return NO_MATCH; }
+  if (memcmp(word->units + (length - suffix_length), suffix, suffix_length * sizeof(uint16_t)) != 0) {
+    return NO_MATCH;
+  }
+  return length - suffix_length;
+}
+
+static size_t strip_first(const ukrainian_word *word, size_t length, suffix_list list, size_t region) {
+  for (size_t i = 0; i < list.count; i++) {
+    size_t stripped = strip(word, length, list.suffixes[i], region);
+    if (stripped != NO_MATCH) { return stripped; }
+  }
+  return NO_MATCH;
+}
+
+static size_t strip_after_a(const ukrainian_word *word, size_t length, suffix_list list) {
+  for (size_t i = 0; i < list.count; i++) {
+    size_t stripped = strip(word, length, list.suffixes[i], word->rv);
+    if (stripped != NO_MATCH && stripped > 0 &&
+        (word->units[stripped - 1] == CYRILLIC_A || word->units[stripped - 1] == CYRILLIC_YA)) {
+      return stripped;
+    }
+  }
+  return NO_MATCH;
+}
+
+static size_t strip_perfective_gerund(const ukrainian_word *word, size_t length) {
+  size_t stripped = strip_after_a(word, length, perfective_gerund_after_a);
+  if (stripped != NO_MATCH) { return stripped; }
+  return strip_first(word, length, perfective_gerund, word->rv);
+}
+
+static size_t strip_adjectival(const ukrainian_word *word, size_t length) {
+  size_t adjective_length = strip_first(word, length, adjective, word->rv);
+  if (adjective_length == NO_MATCH) { return NO_MATCH; }
+  size_t stripped = strip_after_a(word, adjective_length, participle_after_a);
+  if (stripped != NO_MATCH) { return stripped; }
+  stripped = strip_first(word, adjective_length, participle, word->rv);
+  return stripped != NO_MATCH ? stripped : adjective_length;
+}
+
+static size_t strip_verb(const ukrainian_word *word, size_t length) {
+  size_t stripped = strip_after_a(word, length, verb_after_a);
+  if (stripped != NO_MATCH) { return stripped; }
+  return strip_first(word, length, verb, word->rv);
+}
+
+static size_t strip_inflection(const ukrainian_word *word) {
+  size_t stripped = strip_perfective_gerund(word, word->length);
+  if (stripped != NO_MATCH) { return stripped; }
+  size_t base = strip_first(word, word->length, reflexive, word->rv);
+  if (base == NO_MATCH) { base = word->length; }
+  stripped = strip_adjectival(word, base);
+  if (stripped == NO_MATCH) { stripped = strip_verb(word, base); }
+  if (stripped == NO_MATCH) { stripped = strip_first(word, base, noun, word->rv); }
+  return stripped != NO_MATCH ? stripped : base;
+}
+
+static size_t strip_superlative_and_soft_sign(const ukrainian_word *word, size_t length) {
+  size_t stripped = strip(word, length, u"ейше", word->rv);
+  if (stripped == NO_MATCH) { stripped = strip(word, length, u"ейш", word->rv); }
+  if (stripped == NO_MATCH && strip(word, length, u"нн", word->rv) != NO_MATCH) { stripped = length - 1; }
+  if (stripped == NO_MATCH) { stripped = strip(word, length, u"ь", word->rv); }
+  return stripped != NO_MATCH ? stripped : length;
+}
+
+int narsil_ukrainian_stem(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  ukrainian_word word = regions_of(units, length);
+  size_t stemmed = strip_inflection(&word);
+  size_t without_i = strip(&word, stemmed, u"и", word.rv);
+  if (without_i != NO_MATCH) { stemmed = without_i; }
+  size_t derived = strip_first(&word, stemmed, derivational, word.r2);
+  if (derived != NO_MATCH) { stemmed = derived; }
+  stemmed = strip_superlative_and_soft_sign(&word, stemmed);
+  return narsil_text_assign(out, units, stemmed);
+}

package/cpp/core/src/locks.c

@@ -1,4 +1,5 @@
 #include "internal.h"
+#include "thread_yield.h"
 
 #include "../include/narsil_core.h"
 
@@ -6,31 +7,17 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <sched.h>
-#endif
-
 #define LOCK_SPIN_ITERATIONS 128
 #define LIST_COUNT_WORDS 1
 #define LOCK_FREE 0
 #define LOCK_HELD_ALONE (-1)
 
-static inline void yield_thread(void) {
-#ifdef _WIN32
-  SwitchToThread();
-#else
-  sched_yield();
-#endif
-}
-
 static inline void wait_for_the_lock(uint32_t *waits) {
   if (*waits < LOCK_SPIN_ITERATIONS) {
     *waits += 1;
     return;
   }
-  yield_thread();
+  narsil_yield_thread();
 }
 
 static inline uint32_t held_index(uint32_t thread_slot, uint32_t kind) {

package/cpp/core/src/math/apply.c

@@ -0,0 +1,44 @@
+#include "fdlibm.h"
+
+#include "../../include/narsil_core.h"
+#include "../../include/narsil_math.h"
+
+#include <stddef.h>
+
+typedef double (*unary_function)(double value);
+
+static unary_function unary_of(narsil_math_function function) {
+  switch (function) {
+    case NARSIL_MATH_LOG:
+      return fdlibm_log;
+    case NARSIL_MATH_SIN:
+      return fdlibm_sin;
+    case NARSIL_MATH_COS:
+      return fdlibm_cos;
+    case NARSIL_MATH_TAN:
+      return fdlibm_tan;
+    case NARSIL_MATH_ASIN:
+      return fdlibm_asin;
+    case NARSIL_MATH_ATAN:
+      return fdlibm_atan;
+    default:
+      return NULL;
+  }
+}
+
+narsil_status narsil_math_apply(narsil_math_function function, const narsil_math_batch *batch) {
+  if (batch == NULL || (batch->count > 0 && (batch->first == NULL || batch->results == NULL))) {
+    return NARSIL_INVALID_ARGUMENT;
+  }
+  if (function == NARSIL_MATH_ATAN2) {
+    if (batch->count > 0 && batch->second == NULL) { return NARSIL_INVALID_ARGUMENT; }
+    for (size_t index = 0; index < batch->count; index++) {
+      batch->results[index] = fdlibm_atan2(batch->first[index], batch->second[index]);
+    }
+    return NARSIL_OK;
+  }
+  unary_function apply = unary_of(function);
+  if (apply == NULL) { return NARSIL_INVALID_ARGUMENT; }
+  for (size_t index = 0; index < batch->count; index++) { batch->results[index] = apply(batch->first[index]); }
+  return NARSIL_OK;
+}

package/cpp/core/src/math/fdlibm.h

@@ -0,0 +1,16 @@
+#ifndef NARSIL_MATH_FDLIBM_H
+#define NARSIL_MATH_FDLIBM_H
+
+#include <stdint.h>
+
+double fdlibm_log(double value);
+double fdlibm_sin(double value);
+double fdlibm_cos(double value);
+double fdlibm_tan(double value);
+double fdlibm_asin(double value);
+double fdlibm_atan(double value);
+double fdlibm_atan2(double rise, double run);
+
+int32_t fdlibm_rem_pio2(double value, double *out);
+
+#endif