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