SLPrecision.sleela
lib/math/SLPrecision.sleela · 109 line(s) · sleela
<< lib/math/SLPrecision.sleela
SLeeLa Standard Library Definition.
Definition: Defines the SLeeLa standard-library type SLPrecision used within the math library family. >>
#sleela 2.5
material;
< SLeeLa mathematics front-end contract. >
< Native numerical kernels cross an explicit VM bridge. >
class SLPrecision {
< ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
<< Eleven catalogued attributes with getter/setter pairs, so a GUI, loader,
or catalog can read and (where appropriate) override this record.
Values are faithful to the subject's real origin where publicly known. >>
String metaVersion = "1.0.0";
int metaId = 683;
String metaAuthor = "Max Rupplin vs. Dr. Mrs. Elisabeth Harkins";
String metaDate = "2026-10-16";
String metaCopyright = "SLeeLa project";
String metaTrademark = "none";
String metaCorporation = "none";
< metaOrigin: National | <nation> | International | Galactic >
String metaOrigin = "International";
String metaBirthDate = "2026-09-28";
< metaScienceRating: maturity/robustness on a 1..10 scale >
int metaScienceRating = 9;
< metaNationalSchedule: a real, citable instrument or "none" >
String metaNationalSchedule = "none";
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; }
< Number of correct significant digits implied by a relative error. >
int significantDigits(double relativeError) {
double e = relativeError < 0.0 ? 0.0 - relativeError : relativeError;
if (e == 0.0) { return 15; }
int d = 0;
while (e < 1.0 && d < 15) { e = e * 10.0; d = d + 1; }
return d;
}
boolean withinTolerance(double a, double b, double tol) {
double diff = a - b;
if (diff < 0.0) { diff = 0.0 - diff; }
return diff <= tol;
}
< The machine epsilon for IEEE-754 double precision (2^-52). >
double epsilon() { return 0.0000000000000002220446049250313; }
< The largest number of reliable significant decimal digits in a double. >
int maxDigits() { return 15; }
<< Relative-error comparison scaled by the larger operand magnitude, which is
the robust way to compare two computed doubles. Values near zero fall back
to an absolute comparison against epsilon times the tolerance. >>
boolean almostEqual(double a, double b, double relTol) {
double diff = a - b;
if (diff < 0.0) { diff = 0.0 - diff; }
double sa = a < 0.0 ? 0.0 - a : a;
double sb = b < 0.0 ? 0.0 - b : b;
double scale = sa > sb ? sa : sb;
if (scale < epsilon()) { return diff <= relTol * epsilon(); }
return diff <= relTol * scale;
}
<< Agreement in significant decimal digits between two values: how many leading
significant digits a and b share (capped at maxDigits). A higher number
means closer agreement; equal values report the full budget. >>
int agreeingDigits(double a, double b) {
double diff = a - b;
if (diff < 0.0) { diff = 0.0 - diff; }
if (diff == 0.0) { return maxDigits(); }
double sa = a < 0.0 ? 0.0 - a : a;
double sb = b < 0.0 ? 0.0 - b : b;
double scale = sa > sb ? sa : sb;
if (scale == 0.0) { return maxDigits(); }
double rel = diff / scale;
return significantDigits(rel);
}
<< A relative error magnitude |a - b| / |b| between an approximation a and a
reference b; zero reference yields the absolute difference. >>
double relativeError(double approx, double reference) {
double diff = approx - reference;
if (diff < 0.0) { diff = 0.0 - diff; }
double r = reference < 0.0 ? 0.0 - reference : reference;
if (r == 0.0) { return diff; }
return diff / r;
}
}