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 + "]";
}
}