Home /Modules/array/SLIntArray.sleela

SLIntArray.sleela

lib/array/SLIntArray.sleela · 191 line(s) · sleela

<< array/SLIntArray.sleela
   SLeeLa int-array library.
   Definition: Helpers over int[] (SLEELA.syntax section 46): copy, range copy, concat, fill,
   equality, search, sum, minimum, maximum, swap, reverse, heapsort, binary search and text.
   Version neutral: it uses arrayLength, so it runs under any syntax that has arrays. >>
#sleela 3.0
material;
class SLIntArray {
  < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
  << Full descriptive record for a library-family class: identity, legality
     (metaNationalSchedule), fiduciary (copyright, trademark, corporation) and
     jurisdictional scope (metaOrigin). Values are faithful to the real origin
     of the subject where publicly known; unknown values are stated as none. >>
  String metaVersion = "1.0.0";
  int metaId = 8604;
  String metaAuthor = "Max Rupplin";
  String metaDate = "2026-11-12";
  String metaCopyright = "MEARVK LLC";
  String metaTrademark = "none";
  String metaCorporation = "MEARVK LLC";
  String metaOrigin = "International";
  String metaBirthDate = "2026-11-12";
  int metaScienceRating = 7;
  String metaNationalSchedule = "The Java Language Specification, Java SE 28 Edition (JLS 10, Arrays)";

  String getMetaVersion() { return metaVersion; }
  void setMetaVersion(String v) { metaVersion = v; }
  int getMetaId() { return metaId; }
  void setMetaId(int v) { metaId = v; }
  String getAuthor() { return metaAuthor; }
  void setAuthor(String v) { metaAuthor = v; }
  String getDate() { return metaDate; }
  void setDate(String v) { metaDate = v; }
  String getCopyright() { return metaCopyright; }
  void setCopyright(String v) { metaCopyright = v; }
  String getTrademark() { return metaTrademark; }
  void setTrademark(String v) { metaTrademark = v; }
  String getCorporation() { return metaCorporation; }
  void setCorporation(String v) { metaCorporation = v; }
  String getOrigin() { return metaOrigin; }
  void setOrigin(String v) { metaOrigin = v; }
  String getBirthDate() { return metaBirthDate; }
  void setBirthDate(String v) { metaBirthDate = v; }
  int getScienceRating() { return metaScienceRating; }
  void setScienceRating(int v) { metaScienceRating = v; }
  String getNationalSchedule() { return metaNationalSchedule; }
  void setNationalSchedule(String v) { metaNationalSchedule = v; }

  < Throws when index is outside 0..length-1. >
  static void checkIndex(int index, int length) {
    if (index < 0 || index >= length) { throw new RuntimeException("array index out of range: " + index + " for length " + length); }
  }

  static int[] copyOf(int[] a, int n) {
    int[] r = new int[n];
    int m = arrayLength(a);
    if (n < m) { m = n; }
    for (int i = 0; i < m; i++) { r[i] = a[i]; }
    return r;
  }

  < The elements from (inclusive) to to (exclusive). >
  static int[] copyOfRange(int[] a, int from, int to) {
    if (from < 0 || from > to || to > arrayLength(a)) { throw new RuntimeException("bad range " + from + ".." + to); }
    int[] r = new int[to - from];
    for (int i = from; i < to; i++) { r[i - from] = a[i]; }
    return r;
  }

  static int[] concat(int[] a, int[] b) {
    int na = arrayLength(a);
    int nb = arrayLength(b);
    int[] r = new int[na + nb];
    for (int i = 0; i < na; i++) { r[i] = a[i]; }
    for (int j = 0; j < nb; j++) { r[na + j] = b[j]; }
    return r;
  }

  static void fill(int[] a, int v) {
    for (int i = 0; i < arrayLength(a); i++) { a[i] = v; }
  }

  static void fillRange(int[] a, int from, int to, int v) {
    if (from < 0 || from > to || to > arrayLength(a)) { throw new RuntimeException("bad range " + from + ".." + to); }
    for (int i = from; i < to; i++) { a[i] = v; }
  }

  < Same length and the same elements; two null arrays are equal. >
  static boolean isEqual(int[] a, int[] b) {
    if (a == null || b == null) { return a == null && b == null; }
    if (arrayLength(a) != arrayLength(b)) { return false; }
    for (int i = 0; i < arrayLength(a); i++) { if (a[i] != b[i]) { return false; } }
    return true;
  }

  static int indexOf(int[] a, int v) {
    for (int i = 0; i < arrayLength(a); i++) { if (a[i] == v) { return i; } }
    return -1;
  }

  static int lastIndexOf(int[] a, int v) {
    for (int i = arrayLength(a) - 1; i >= 0; i--) { if (a[i] == v) { return i; } }
    return -1;
  }

  static boolean contains(int[] a, int v) { return indexOf(a, v) >= 0; }

  static int sumOf(int[] a) {
    int s = 0;
    for (int i = 0; i < arrayLength(a); i++) { s = s + a[i]; }
    return s;
  }

  static int minOf(int[] a) {
    if (arrayLength(a) == 0) { throw new RuntimeException("minOf of an empty array"); }
    int m = a[0];
    for (int i = 1; i < arrayLength(a); i++) { if (a[i] < m) { m = a[i]; } }
    return m;
  }

  static int maxOf(int[] a) {
    if (arrayLength(a) == 0) { throw new RuntimeException("maxOf of an empty array"); }
    int m = a[0];
    for (int i = 1; i < arrayLength(a); i++) { if (a[i] > m) { m = a[i]; } }
    return m;
  }

  static void swap(int[] a, int i, int j) {
    checkIndex(i, arrayLength(a));
    checkIndex(j, arrayLength(a));
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
  }

  static void reverse(int[] a) {
    int i = 0;
    int j = arrayLength(a) - 1;
    while (i < j) { int t = a[i]; a[i] = a[j]; a[j] = t; i++; j--; }
  }

  < In-place ascending sort (heapsort: O(n log n), no recursion, not stable). >
  static void sort(int[] a) {
    int n = arrayLength(a);
    int start = n / 2 - 1;
    while (start >= 0) { siftDown(a, start, n); start--; }
    int end = n - 1;
    while (end > 0) {
      int t = a[0]; a[0] = a[end]; a[end] = t;
      siftDown(a, 0, end);
      end--;
    }
  }

  static void siftDown(int[] a, int root, int n) {
    int r = root;
    while (true) {
      int child = 2 * r + 1;
      if (child >= n) { return; }
      if (child + 1 < n && a[child + 1] > a[child]) { child = child + 1; }
      if (a[r] >= a[child]) { return; }
      int t = a[r]; a[r] = a[child]; a[child] = t;
      r = child;
    }
  }

  < Index of key in an ascending array, or -(insertion point)-1 when absent. >
  static int binarySearch(int[] a, int key) {
    int lo = 0;
    int hi = arrayLength(a) - 1;
    while (lo <= hi) {
      int mid = (lo + hi) / 2;
      if (a[mid] < key) { lo = mid + 1; }
      else if (a[mid] > key) { hi = mid - 1; }
      else { return mid; }
    }
    return -(lo + 1);
  }

  < Text like [1, 2, 3]; null prints as null. >
  static String toText(int[] a) {
    if (a == null) { return "null"; }
    String s = "[";
    for (int i = 0; i < arrayLength(a); i++) {
      if (i > 0) { s = s + ", "; }
      s = s + a[i];
    }
    return s + "]";
  }
}