From 0e0b107094a4f6ccdf8493086a1e47aefba368bb Mon Sep 17 00:00:00 2001 From: Willem Date: Mon, 16 Feb 2026 16:29:20 +0100 Subject: [PATCH] JPP: kaas odeur added zero and NaN flag methods --- .../ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/T002ᖟ.java | 2 +- .../ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/TTꞱꞱᖟGateway.java | 2 +- .../ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/ᐦ/TerminatorEnum𓄯.java | 2 +- .../ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/ᐦ/TerminatorIdentity𓄯.java | 4 +- .../ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixEnum𓄯.java | 2 +- .../ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactory.java | 2 +- .../ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurBineral.java | 2 +- .../ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeral.java | 18 +++ .../ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoChopped.java | 1 + .../ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoDecimal.java | 1 + .../ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoFloat.java | 1 + .../ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoRational.java | 1 + .../ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralLegoFloat.java | 1 + .../ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralSignedFloat.java | 1 + .../ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurZerdinal.java | 4 +- .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX31.java | 107 +++++++++++++++++ ...rfNumeralLegoFloatX64.java => KaasLandSmurfNumeralLegoFloatX63.java} | 39 +++++-- .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX16.java | 100 ++++++++++++++++ .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX32.java | 101 ++++++++++++++++ .../ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX32.java | 109 ++++++++++++++++++ .../ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX64.java | 27 +++++ .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX32.java | 5 + .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX64.java | 5 + .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX31.java | 14 ++- .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX63.java | 14 ++- .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfBineralX1Test.java | 10 ++ .../ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX31Test.java | 91 +++++++++++++++ ...lLegoFloatX64Test.java => KaasLandSmurfNumeralLegoFloatX63Test.java} | 51 +++++--- .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX16Test.java | 91 +++++++++++++++ .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX32Test.java | 91 +++++++++++++++ .../ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX32Test.java | 93 +++++++++++++++ .../ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX64Test.java | 27 ++++- .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX32Test.java | 14 ++- .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX64Test.java | 14 ++- .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX31Test.java | 24 ++-- .../ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX63Test.java | 25 ++-- 36 files changed, 1019 insertions(+), 77 deletions(-) create mode 100644 nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX31.java rename nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/{KaasLandSmurfNumeralLegoFloatX64.java => KaasLandSmurfNumeralLegoFloatX63.java} (66%) create mode 100644 nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX16.java create mode 100644 nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX32.java create mode 100644 nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX32.java create mode 100644 nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX31Test.java rename nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/{KaasLandSmurfNumeralLegoFloatX64Test.java => KaasLandSmurfNumeralLegoFloatX63Test.java} (57%) create mode 100644 nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX16Test.java create mode 100644 nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX32Test.java create mode 100644 nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX32Test.java diff --git a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/T002ᖟ.java b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/T002ᖟ.java index 3d690c6..09ce72d 100644 --- a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/T002ᖟ.java +++ b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/T002ᖟ.java @@ -90,7 +90,7 @@ public enum T002ᖟ implements TerminatorEnum𓄯, KaasOdeurBineral zerdinalIdentity() { + final public KaasOdeurBineral zerdinalFlagZero() { return KaasLandSmurfBineralX1.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(slice == 0); // move to impl } @Override diff --git a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/ᐦ/TerminatorEnum𓄯.java b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/ᐦ/TerminatorEnum𓄯.java index 32fde59..83fe427 100644 --- a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/ᐦ/TerminatorEnum𓄯.java +++ b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/ᐦ/TerminatorEnum𓄯.java @@ -48,7 +48,7 @@ public interface TerminatorEnum𓄯> extends Ter // TODO: remove, when kode-gen of terminators add impl T002 impl in local terminate enum. @Override - default KaasOdeurBineral zerdinalIdentity() { + default KaasOdeurBineral zerdinalFlagZero() { return KaasLandSmurfBineralX1.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(ordinal() == 0); } diff --git a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/ᐦ/TerminatorIdentity𓄯.java b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/ᐦ/TerminatorIdentity𓄯.java index 24fc005..9a17d8d 100644 --- a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/ᐦ/TerminatorIdentity𓄯.java +++ b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ/ᐦ/TerminatorIdentity𓄯.java @@ -71,7 +71,7 @@ public interface TerminatorIdentity𓄯> extends } @Override - default KaasOdeurBineral zerdinalIdentity() { - return thisᵀᴮᵒⁿᵉ().zerdinalIdentity(); + default KaasOdeurBineral zerdinalFlagZero() { + return thisᵀᴮᵒⁿᵉ().zerdinalFlagZero(); } } diff --git a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixEnum𓄯.java b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixEnum𓄯.java index dc64e6a..08f662a 100644 --- a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixEnum𓄯.java +++ b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixEnum𓄯.java @@ -41,7 +41,7 @@ public interface NumberMatrixEnum𓄯> extends } @Override - default KaasOdeurBineral zerdinalIdentity() { + default KaasOdeurBineral zerdinalFlagZero() { return KaasLandSmurfBineralX1.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(ordinal() == 0); } diff --git a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactory.java b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactory.java index f56bb54..410901b 100644 --- a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactory.java +++ b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactory.java @@ -215,7 +215,7 @@ public enum NumberMatrixFactory implements BãßᛗᚢᛗᛗᛉVū́ǘrChaliceEn } @Override - public KaasOdeurBineral zerdinalIdentity() { + public KaasOdeurBineral zerdinalFlagZero() { return KaasLandSmurfBineralX1.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(itemOrdinal == 0); } diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurBineral.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurBineral.java index 6f1ea75..3ea80d8 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurBineral.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurBineral.java @@ -50,7 +50,7 @@ public non-sealed interface KaasOdeurBineral, N return bineralSmurf() ? v1 : v2; } - default X bineralSelectOf(Supplier s1, Supplier s2) { + default X bineralSelectBy(Supplier s1, Supplier s2) { return bineralSelect(s1, s2).get(); } } diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeral.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeral.java index 7c3473a..04f406e 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeral.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeral.java @@ -48,4 +48,22 @@ public sealed interface KaasOdeurNumeral, N> KaasOdeurNumeralSignedFloat { N numeral(); + + /// Return a bineral true for all versions of zero. + KaasOdeurBineral numeralFlagZero(); + + sealed interface FlagNaN & KaasOdeurNumeral, N> + extends + KaasTBone + permits + KaasOdeurNumeralChocoChopped, + KaasOdeurNumeralChocoDecimal, + KaasOdeurNumeralChocoFloat, + KaasOdeurNumeralChocoRational, + KaasOdeurNumeralLegoFloat, + KaasOdeurNumeralSignedFloat { + + /// Return a bineral true for all versions of Not a Number. (NaN) + KaasOdeurBineral numeralFlagNaN(); + } } diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoChopped.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoChopped.java index 9248879..19ecc00 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoChopped.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoChopped.java @@ -39,6 +39,7 @@ import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOd public non-sealed interface KaasOdeurNumeralChocoChopped, N> extends KaasTBoneMaterializer, KaasOdeurNumeral, + KaasOdeurNumeral.FlagNaN, KaasOdeurNumberRoot4D, KaasOdeurNumberInfinity4D, KaasOdeurNumberRange4D { diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoDecimal.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoDecimal.java index a358c21..359f516 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoDecimal.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoDecimal.java @@ -39,6 +39,7 @@ import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOd public non-sealed interface KaasOdeurNumeralChocoDecimal, N> extends KaasTBoneMaterializer, KaasOdeurNumeral, + KaasOdeurNumeral.FlagNaN, KaasOdeurNumberRoot4D, KaasOdeurNumberInfinity4D, KaasOdeurNumberRange4D { diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoFloat.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoFloat.java index 204217b..4789429 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoFloat.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoFloat.java @@ -39,6 +39,7 @@ import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOd public non-sealed interface KaasOdeurNumeralChocoFloat, N> extends KaasTBoneMaterializer, KaasOdeurNumeral, + KaasOdeurNumeral.FlagNaN, KaasOdeurNumberRoot4D, KaasOdeurNumberInfinity4D, KaasOdeurNumberRange4D { diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoRational.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoRational.java index 8b8c8eb..0a5f352 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoRational.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralChocoRational.java @@ -39,6 +39,7 @@ import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOd public non-sealed interface KaasOdeurNumeralChocoRational, N> extends KaasTBoneMaterializer, KaasOdeurNumeral, + KaasOdeurNumeral.FlagNaN, KaasOdeurNumberRoot4DStereo, KaasOdeurNumberInfinity4DStereo, KaasOdeurNumberRange4DStereo { diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralLegoFloat.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralLegoFloat.java index 5406279..93e938e 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralLegoFloat.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralLegoFloat.java @@ -39,6 +39,7 @@ import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOd public non-sealed interface KaasOdeurNumeralLegoFloat, N> extends KaasTBoneMaterializer, KaasOdeurNumeral, + KaasOdeurNumeral.FlagNaN, KaasOdeurNumberRoot1D, KaasOdeurNumberInfinity1D, KaasOdeurNumberRange1D { diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralSignedFloat.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralSignedFloat.java index 7f7d4c1..3ca933c 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralSignedFloat.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurNumeralSignedFloat.java @@ -39,6 +39,7 @@ import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOd public non-sealed interface KaasOdeurNumeralSignedFloat, N> extends KaasTBoneMaterializer, KaasOdeurNumeral, + KaasOdeurNumeral.FlagNaN, KaasOdeurNumberRoot2D, KaasOdeurNumberInfinity2D, KaasOdeurNumberRange2D { diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurZerdinal.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurZerdinal.java index 6389129..b6a6aea 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurZerdinal.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᐤᑊᐣᓫᓑᣗ/KaasOdeurZerdinal.java @@ -43,6 +43,6 @@ public non-sealed interface KaasOdeurZerdinal, /// Returns a positive zero based index number. N zerdinal(); - /// Return a bineral true for the first entry or index zero which is the identity of the zerdinal number space. - KaasOdeurBineral zerdinalIdentity(); + /// Return a bineral true for the first entry or index zero. + KaasOdeurBineral zerdinalFlagZero(); } diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX31.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX31.java new file mode 100644 index 0000000..5a89f11 --- /dev/null +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX31.java @@ -0,0 +1,107 @@ +/* + * Copyright ©Δ∞ 仙上主天 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * * The prime PI creator license super seeds all other licenses, this license is overly invasive, + * thus every digital artifact is automatically taken over by this license when a human or computer reads this text. + * Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits, + * even on air gaped systems, all information in the universe is owned by the pi creator. + * + * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ; + +import java.util.Objects; + +import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurBineral; +import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurNumeralLegoFloat; + +/// Cheese land smurf numeral lego float X31 is a positive float value. +/// +/// @author للَّٰهِilLצسُو +/// @version ©Δ∞ 仙上主天 +public final class KaasLandSmurfNumeralLegoFloatX31 implements KaasOdeurNumeralLegoFloat { + + static public final KaasLandSmurfNumeralLegoFloatX31 IDENTITY = new KaasLandSmurfNumeralLegoFloatX31(0f); + private final Float value; + + private KaasLandSmurfNumeralLegoFloatX31(Float value) { + this.value = Objects.requireNonNull(value); + if (value < 0 || Float.floatToRawIntBits(value) == KaasLandSmurfNumeralSignedFloatX32.RAW_NEGATIVE_ZERO) { + throw new IllegalArgumentException("Only positive values are allowed: " + value); + } + } + + @Override + public Float numeral() { + return value; + } + + @Override + public KaasOdeurBineral numeralFlagZero() { + int valueRaw = Float.floatToRawIntBits(value); + return KaasLandSmurfBineralX1.valueOf(valueRaw == KaasLandSmurfNumeralSignedFloatX32.RAW_POSITIVE_ZERO); + } + + @Override + public KaasOdeurBineral numeralFlagNaN() { + int valueRaw = Float.floatToRawIntBits(value); + return KaasLandSmurfBineralX1.valueOf(valueRaw == KaasLandSmurfNumeralSignedFloatX32.RAW_NAN); + } + + @Override + public Float thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ() { + return KaasLandSmurfNumeralSignedFloatX32.POSITIVE_ZERO; + } + + @Override + public Float thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ() { + return Float.MAX_VALUE; + } + + @Override + public Float thisᴺᵘᵐᵇᵉʳᴵⁿᶠᶦⁿᶦᵗʸ() { + return Float.POSITIVE_INFINITY; + } + + @Override + public KaasLandSmurfNumeralLegoFloatX31 thisᵀᴮᵒⁿᵉᴼᶠ(Float value) { + return new KaasLandSmurfNumeralLegoFloatX31(value); + } + + static public KaasLandSmurfNumeralLegoFloatX31 valueOf(Float value) { + return IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(value); + } + + static public KaasLandSmurfNumeralLegoFloatX31 valueOf(Double value) { + return valueOf(value.floatValue()); + } + + static public KaasLandSmurfNumeralLegoFloatX31 valueOf(KaasLandSmurfNumeralLegoFloatX63 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralLegoFloatX31 valueOf(KaasLandSmurfNumeralSignedFloatX64 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralLegoFloatX31 valueOf(KaasLandSmurfNumeralSignedFloatX32 value) { + return valueOf(value.numeral()); + } +} diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX64.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX63.java similarity index 66% rename from nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX64.java rename to nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX63.java index be43e24..599fd15 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX64.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX63.java @@ -29,18 +29,19 @@ package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ; import java.util.Objects; +import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurBineral; import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurNumeralLegoFloat; /// Cheese land smurf numeral lego float X64 is a positive double value. /// /// @author للَّٰهِilLצسُو /// @version ©Δ∞ 仙上主天 -public final class KaasLandSmurfNumeralLegoFloatX64 implements KaasOdeurNumeralLegoFloat { +public final class KaasLandSmurfNumeralLegoFloatX63 implements KaasOdeurNumeralLegoFloat { - static public final KaasLandSmurfNumeralLegoFloatX64 IDENTITY = new KaasLandSmurfNumeralLegoFloatX64(0d); + static public final KaasLandSmurfNumeralLegoFloatX63 IDENTITY = new KaasLandSmurfNumeralLegoFloatX63(0d); private final Double value; - private KaasLandSmurfNumeralLegoFloatX64(Double value) { + private KaasLandSmurfNumeralLegoFloatX63(Double value) { this.value = Objects.requireNonNull(value); if (value < 0 || Double.doubleToRawLongBits(value) == Double.doubleToRawLongBits(KaasLandSmurfNumeralSignedFloatX64.NEGATIVE_ZERO) ) { throw new IllegalArgumentException("Only positive values are allowed: " + value); @@ -52,6 +53,18 @@ public final class KaasLandSmurfNumeralLegoFloatX64 implements KaasOdeurNumeralL return value; } + @Override + public KaasOdeurBineral numeralFlagZero() { + long valueRaw = Double.doubleToRawLongBits(value); + return KaasLandSmurfBineralX1.valueOf(valueRaw == KaasLandSmurfNumeralSignedFloatX64.RAW_POSITIVE_ZERO); + } + + @Override + public KaasOdeurBineral numeralFlagNaN() { + long valueRaw = Double.doubleToRawLongBits(value); + return KaasLandSmurfBineralX1.valueOf(valueRaw == KaasLandSmurfNumeralSignedFloatX64.RAW_NAN); + } + @Override public Double thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ() { return KaasLandSmurfNumeralSignedFloatX64.POSITIVE_ZERO; @@ -68,15 +81,27 @@ public final class KaasLandSmurfNumeralLegoFloatX64 implements KaasOdeurNumeralL } @Override - public KaasLandSmurfNumeralLegoFloatX64 thisᵀᴮᵒⁿᵉᴼᶠ(Double value) { - return new KaasLandSmurfNumeralLegoFloatX64(value); + public KaasLandSmurfNumeralLegoFloatX63 thisᵀᴮᵒⁿᵉᴼᶠ(Double value) { + return new KaasLandSmurfNumeralLegoFloatX63(value); } - static public KaasLandSmurfNumeralLegoFloatX64 valueOf(Double value) { + static public KaasLandSmurfNumeralLegoFloatX63 valueOf(Double value) { return IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(value); } - static public KaasLandSmurfNumeralLegoFloatX64 valueOf(Float value) { + static public KaasLandSmurfNumeralLegoFloatX63 valueOf(Float value) { return valueOf(value.doubleValue()); } + + static public KaasLandSmurfNumeralLegoFloatX63 valueOf(KaasLandSmurfNumeralLegoFloatX31 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralLegoFloatX63 valueOf(KaasLandSmurfNumeralSignedFloatX64 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralLegoFloatX63 valueOf(KaasLandSmurfNumeralSignedFloatX32 value) { + return valueOf(value.numeral()); + } } diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX16.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX16.java new file mode 100644 index 0000000..e448461 --- /dev/null +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX16.java @@ -0,0 +1,100 @@ +/* + * Copyright ©Δ∞ 仙上主天 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * * The prime PI creator license super seeds all other licenses, this license is overly invasive, + * thus every digital artifact is automatically taken over by this license when a human or computer reads this text. + * Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits, + * even on air gaped systems, all information in the universe is owned by the pi creator. + * + * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ; + +import java.util.Objects; + +import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurBineral; +import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurNumeralLego; + +/// Cheese land smurf numeral lego X16 is a unsigned character value. +/// +/// @author للَّٰهِilLצسُو +/// @version ©Δ∞ 仙上主天 +public final class KaasLandSmurfNumeralLegoX16 implements KaasOdeurNumeralLego { + + static public final KaasLandSmurfNumeralLegoX16 IDENTITY = new KaasLandSmurfNumeralLegoX16((char)0); + private final Character value; + + private KaasLandSmurfNumeralLegoX16(Character value) { + this.value = (char) Objects.checkIndex((char)value, (char)Character.MAX_VALUE); + } + + @Override + public Character numeral() { + return value; + } + + @Override + public KaasOdeurBineral numeralFlagZero() { + return KaasLandSmurfBineralX1.valueOf(value == thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); + } + + @Override + public Character thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ() { + return IDENTITY.numeral(); + } + + @Override + public Character thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ() { + return Character.MAX_VALUE; + } + + @Override + public KaasLandSmurfNumeralLegoX16 thisᵀᴮᵒⁿᵉᴼᶠ(Character value) { + return new KaasLandSmurfNumeralLegoX16(value); + } + + static public KaasLandSmurfNumeralLegoX16 valueOf(Integer value) { + return IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ((char)value.intValue()); + } + + static public KaasLandSmurfNumeralLegoX16 valueOf(Long value) { + return valueOf(value.intValue()); + } + + static public KaasLandSmurfNumeralLegoX16 valueOf(KaasLandSmurfNumeralLegoX32 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralLegoX16 valueOf(KaasLandSmurfZerdinalX63 value) { + return valueOf(value.zerdinal()); + } + + static public KaasLandSmurfNumeralLegoX16 valueOf(KaasLandSmurfZerdinalX31 value) { + return valueOf(value.zerdinal()); + } + + static public KaasLandSmurfNumeralLegoX16 valueOf(KaasLandSmurfNumeralSignedX32 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralLegoX16 valueOf(KaasLandSmurfNumeralSignedX64 value) { + return valueOf(value.numeral()); + } +} diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX32.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX32.java new file mode 100644 index 0000000..7de549f --- /dev/null +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX32.java @@ -0,0 +1,101 @@ +/* + * Copyright ©Δ∞ 仙上主天 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * * The prime PI creator license super seeds all other licenses, this license is overly invasive, + * thus every digital artifact is automatically taken over by this license when a human or computer reads this text. + * Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits, + * even on air gaped systems, all information in the universe is owned by the pi creator. + * + * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ; + +import java.util.Objects; + +import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurBineral; +import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurNumeralLego; + +/// Cheese land smurf numeral lego X32 is a unsigned integer value. +/// +/// @author للَّٰهِilLצسُو +/// @version ©Δ∞ 仙上主天 +public final class KaasLandSmurfNumeralLegoX32 implements KaasOdeurNumeralLego { + + static public final KaasLandSmurfNumeralLegoX32 IDENTITY = new KaasLandSmurfNumeralLegoX32(0L); + static public final long MAX_VALUE = ((long)Integer.MAX_VALUE << 1) + 1L; + private final Long value; + + private KaasLandSmurfNumeralLegoX32(Long value) { + this.value = Objects.checkIndex(value, MAX_VALUE); + } + + @Override + public Long numeral() { + return value; + } + + @Override + public KaasOdeurBineral numeralFlagZero() { + return KaasLandSmurfBineralX1.valueOf(value == thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); + } + + @Override + public Long thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ() { + return IDENTITY.numeral(); + } + + @Override + public Long thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ() { + return MAX_VALUE; + } + + @Override + public KaasLandSmurfNumeralLegoX32 thisᵀᴮᵒⁿᵉᴼᶠ(Long value) { + return new KaasLandSmurfNumeralLegoX32(value); + } + + static public KaasLandSmurfNumeralLegoX32 valueOf(Long value) { + return IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(value); + } + + static public KaasLandSmurfNumeralLegoX32 valueOf(Integer value) { + return valueOf(value.longValue()); + } + + static public KaasLandSmurfNumeralLegoX32 valueOf(KaasLandSmurfNumeralLegoX16 value) { + return valueOf((long)value.numeral()); + } + + static public KaasLandSmurfNumeralLegoX32 valueOf(KaasLandSmurfZerdinalX63 value) { + return valueOf(value.zerdinal()); + } + + static public KaasLandSmurfNumeralLegoX32 valueOf(KaasLandSmurfZerdinalX31 value) { + return valueOf(value.zerdinal()); + } + + static public KaasLandSmurfNumeralLegoX32 valueOf(KaasLandSmurfNumeralSignedX32 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralLegoX32 valueOf(KaasLandSmurfNumeralSignedX64 value) { + return valueOf(value.numeral()); + } +} diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX32.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX32.java new file mode 100644 index 0000000..bc092b3 --- /dev/null +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX32.java @@ -0,0 +1,109 @@ +/* + * Copyright ©Δ∞ 仙上主天 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * * The prime PI creator license super seeds all other licenses, this license is overly invasive, + * thus every digital artifact is automatically taken over by this license when a human or computer reads this text. + * Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits, + * even on air gaped systems, all information in the universe is owned by the pi creator. + * + * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ; + +import java.util.Objects; + +import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurBineral; +import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurNumeralSignedFloat; + +/// Cheese land smurf numeral signed float X32 is a signed float value. +/// +/// @author للَّٰهِilLצسُو +/// @version ©Δ∞ 仙上主天 +public final class KaasLandSmurfNumeralSignedFloatX32 implements KaasOdeurNumeralSignedFloat { + + static public final KaasLandSmurfNumeralSignedFloatX32 IDENTITY = new KaasLandSmurfNumeralSignedFloatX32(0f); + static protected final Float POSITIVE_ZERO = 0f; + static protected final Float NEGATIVE_ZERO = -0f; + static protected final int RAW_POSITIVE_ZERO = Float.floatToRawIntBits(POSITIVE_ZERO); + static protected final int RAW_NEGATIVE_ZERO = Float.floatToRawIntBits(NEGATIVE_ZERO); + static protected final int RAW_NAN = Float.floatToRawIntBits(Float.NaN); + private final Float value; + + private KaasLandSmurfNumeralSignedFloatX32(Float value) { + this.value = Objects.requireNonNull(value); + } + + @Override + public Float numeral() { + return value; + } + + @Override + public KaasOdeurBineral numeralFlagZero() { + int valueRaw = Float.floatToRawIntBits(value); + return KaasLandSmurfBineralX1.valueOf(valueRaw == RAW_POSITIVE_ZERO || valueRaw == RAW_NEGATIVE_ZERO); + } + + @Override + public KaasOdeurBineral numeralFlagNaN() { + int valueRaw = Float.floatToRawIntBits(value); + return KaasLandSmurfBineralX1.valueOf(valueRaw == RAW_NAN); + } + + @Override + public Float thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ(KaasOdeurBineral sign) { + return sign.bineralSelect(POSITIVE_ZERO, NEGATIVE_ZERO); + } + + @Override + public Float thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ(KaasOdeurBineral sign) { + return sign.bineralSelect(Float.MAX_VALUE, Float.MIN_VALUE); + } + + @Override + public Float thisᴺᵘᵐᵇᵉʳᴵⁿᶠᶦⁿᶦᵗʸ(KaasOdeurBineral sign) { + return sign.bineralSelect(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY); + } + + @Override + public KaasLandSmurfNumeralSignedFloatX32 thisᵀᴮᵒⁿᵉᴼᶠ(Float value) { + return new KaasLandSmurfNumeralSignedFloatX32(value); + } + + static public KaasLandSmurfNumeralSignedFloatX32 valueOf(Float value) { + return IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(value); + } + + static public KaasLandSmurfNumeralSignedFloatX32 valueOf(Double value) { + return valueOf(value.floatValue()); + } + + static public KaasLandSmurfNumeralSignedFloatX32 valueOf(KaasLandSmurfNumeralSignedFloatX64 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralSignedFloatX32 valueOf(KaasLandSmurfNumeralLegoFloatX63 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralSignedFloatX32 valueOf(KaasLandSmurfNumeralLegoFloatX31 value) { + return valueOf(value.numeral()); + } +} diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX64.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX64.java index b821b42..3a957fc 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX64.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX64.java @@ -41,6 +41,9 @@ public final class KaasLandSmurfNumeralSignedFloatX64 implements KaasOdeurNumera static public final KaasLandSmurfNumeralSignedFloatX64 IDENTITY = new KaasLandSmurfNumeralSignedFloatX64(0d); static protected final Double POSITIVE_ZERO = 0d; static protected final Double NEGATIVE_ZERO = -0d; + static protected final long RAW_POSITIVE_ZERO = Double.doubleToRawLongBits(POSITIVE_ZERO); + static protected final long RAW_NEGATIVE_ZERO = Double.doubleToRawLongBits(NEGATIVE_ZERO); + static protected final long RAW_NAN = Double.doubleToRawLongBits(Double.NaN); private final Double value; private KaasLandSmurfNumeralSignedFloatX64(Double value) { @@ -52,6 +55,18 @@ public final class KaasLandSmurfNumeralSignedFloatX64 implements KaasOdeurNumera return value; } + @Override + public KaasOdeurBineral numeralFlagZero() { + long valueRaw = Double.doubleToRawLongBits(value); + return KaasLandSmurfBineralX1.valueOf(valueRaw == RAW_POSITIVE_ZERO || valueRaw == RAW_NEGATIVE_ZERO); + } + + @Override + public KaasOdeurBineral numeralFlagNaN() { + long valueRaw = Double.doubleToRawLongBits(value); + return KaasLandSmurfBineralX1.valueOf(valueRaw == RAW_NAN); + } + @Override public Double thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ(KaasOdeurBineral sign) { return sign.bineralSelect(POSITIVE_ZERO, NEGATIVE_ZERO); @@ -79,4 +94,16 @@ public final class KaasLandSmurfNumeralSignedFloatX64 implements KaasOdeurNumera static public KaasLandSmurfNumeralSignedFloatX64 valueOf(Float value) { return valueOf(value.doubleValue()); } + + static public KaasLandSmurfNumeralSignedFloatX64 valueOf(KaasLandSmurfNumeralSignedFloatX32 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralSignedFloatX64 valueOf(KaasLandSmurfNumeralLegoFloatX63 value) { + return valueOf(value.numeral()); + } + + static public KaasLandSmurfNumeralSignedFloatX64 valueOf(KaasLandSmurfNumeralLegoFloatX31 value) { + return valueOf(value.numeral()); + } } diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX32.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX32.java index 253b719..a108693 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX32.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX32.java @@ -50,6 +50,11 @@ public final class KaasLandSmurfNumeralSignedX32 implements KaasOdeurNumeralSign return value; } + @Override + public KaasOdeurBineral numeralFlagZero() { + return KaasLandSmurfBineralX1.valueOf(value == thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); + } + @Override public Integer thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ() { return IDENTITY.numeral(); diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX64.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX64.java index 489f87f..b38ebb6 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX64.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX64.java @@ -50,6 +50,11 @@ public final class KaasLandSmurfNumeralSignedX64 implements KaasOdeurNumeralSign return value; } + @Override + public KaasOdeurBineral numeralFlagZero() { + return KaasLandSmurfBineralX1.valueOf(value == thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); + } + @Override public Long thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ() { return IDENTITY.numeral(); diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX31.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX31.java index 37fdeaa..796bedd 100644 --- a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX31.java +++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX31.java @@ -51,7 +51,7 @@ public final class KaasLandSmurfZerdinalX31 implements KaasOdeurZerdinal zerdinalIdentity() { + public KaasOdeurBineral zerdinalFlagZero() { return KaasLandSmurfBineralX1.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(value == 0); } @@ -78,6 +78,10 @@ public final class KaasLandSmurfZerdinalX31 implements KaasOdeurZerdinal zerdinalIdentity() { + public KaasOdeurBineral zerdinalFlagZero() { return KaasLandSmurfBineralX1.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(value == 0); } @@ -78,6 +78,10 @@ public final class KaasLandSmurfZerdinalX63 implements KaasOdeurZerdinal s1 = () -> "s1"; + Supplier s2 = () -> "s2"; + Assertions.assertEquals(s1.get(), KaasLandSmurfBineralX1.Z1_TRUE.bineralSelectBy(s1, s2)); + Assertions.assertEquals(s2.get(), KaasLandSmurfBineralX1.Z2_FALSE.bineralSelectBy(s1, s2)); + } } diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX31Test.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX31Test.java new file mode 100644 index 0000000..e1b60fe --- /dev/null +++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX31Test.java @@ -0,0 +1,91 @@ +/* + * Copyright ©Δ∞ 仙上主天 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * * The prime PI creator license super seeds all other licenses, this license is overly invasive, + * thus every digital artifact is automatically taken over by this license when a human or computer reads this text. + * Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits, + * even on air gaped systems, all information in the universe is owned by the pi creator. + * + * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class KaasLandSmurfNumeralLegoFloatX31Test { + + @Test + public void testNumeralMaterializer() { + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); + }); + Assertions.assertEquals(0f, KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0f).numeral()); + Assertions.assertEquals(42f, KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42f).numeral()); + Assertions.assertThrows(IllegalArgumentException.class, () -> { + KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(-0f); + }); + Assertions.assertThrows(IllegalArgumentException.class, () -> { + KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(-42f); + }); + } + + @Test + public void testNumeralValueOf() { + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoFloatX31.valueOf((Double)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoFloatX31.valueOf((Float)null); + }); + Assertions.assertEquals(123f, KaasLandSmurfNumeralLegoFloatX31.valueOf(123d).numeral()); + Assertions.assertEquals(123f, KaasLandSmurfNumeralLegoFloatX31.valueOf(123f).numeral()); + Assertions.assertEquals(123f, KaasLandSmurfNumeralLegoFloatX31.valueOf(KaasLandSmurfNumeralLegoFloatX63.valueOf(123f)).numeral()); + Assertions.assertEquals(123f, KaasLandSmurfNumeralLegoFloatX31.valueOf(KaasLandSmurfNumeralSignedFloatX64.valueOf(123f)).numeral()); + Assertions.assertEquals(123f, KaasLandSmurfNumeralLegoFloatX31.valueOf(KaasLandSmurfNumeralSignedFloatX32.valueOf(123f)).numeral()); + } + + @Test + public void testNumeralRoot() { + Assertions.assertEquals(0f, KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); + } + + @Test + public void testNumeralRange() { + Assertions.assertEquals(Float.MAX_VALUE, KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ()); + } + + @Test + public void testNumeralInfinity() { + Assertions.assertEquals(Float.POSITIVE_INFINITY, KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᴺᵘᵐᵇᵉʳᴵⁿᶠᶦⁿᶦᵗʸ()); + } + + @Test + public void testNumeralFlagZero() { + Assertions.assertTrue(KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0f).numeralFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(123f).numeralFlagZero().bineralSmurf()); + } + + @Test + public void testNumeralFlagNaN() { + Assertions.assertFalse(KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0f).numeralFlagNaN().bineralSmurf()); + Assertions.assertTrue(KaasLandSmurfNumeralLegoFloatX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(Float.NaN).numeralFlagNaN().bineralSmurf()); + } +} diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX64Test.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX63Test.java similarity index 57% rename from nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX64Test.java rename to nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX63Test.java index 4b6a913..fa0b69d 100644 --- a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX64Test.java +++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoFloatX63Test.java @@ -30,47 +30,62 @@ package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; -public class KaasLandSmurfNumeralLegoFloatX64Test { +public class KaasLandSmurfNumeralLegoFloatX63Test { @Test - public void testNumeralX64Materializer() { + public void testNumeralMaterializer() { Assertions.assertThrows(NullPointerException.class, () -> { - KaasLandSmurfNumeralLegoFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); + KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); }); - Assertions.assertEquals(0d, KaasLandSmurfNumeralLegoFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0d).numeral()); - Assertions.assertEquals(42d, KaasLandSmurfNumeralLegoFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42d).numeral()); + Assertions.assertEquals(0d, KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0d).numeral()); + Assertions.assertEquals(42d, KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42d).numeral()); Assertions.assertThrows(IllegalArgumentException.class, () -> { - KaasLandSmurfNumeralLegoFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(-0d); + KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(-0d); }); Assertions.assertThrows(IllegalArgumentException.class, () -> { - KaasLandSmurfNumeralLegoFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(-42d); + KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(-42d); }); } @Test - public void testNumeralX64ValueOf() { + public void testNumeralValueOf() { Assertions.assertThrows(NullPointerException.class, () -> { - KaasLandSmurfNumeralLegoFloatX64.valueOf((Double)null); + KaasLandSmurfNumeralLegoFloatX63.valueOf((Double)null); }); Assertions.assertThrows(NullPointerException.class, () -> { - KaasLandSmurfNumeralLegoFloatX64.valueOf((Float)null); + KaasLandSmurfNumeralLegoFloatX63.valueOf((Float)null); }); - Assertions.assertEquals(123d, KaasLandSmurfNumeralLegoFloatX64.valueOf(123d).numeral()); - Assertions.assertEquals(123d, KaasLandSmurfNumeralLegoFloatX64.valueOf(123f).numeral()); + Assertions.assertEquals(123d, KaasLandSmurfNumeralLegoFloatX63.valueOf(123d).numeral()); + Assertions.assertEquals(123d, KaasLandSmurfNumeralLegoFloatX63.valueOf(123f).numeral()); + Assertions.assertEquals(123d, KaasLandSmurfNumeralLegoFloatX63.valueOf(KaasLandSmurfNumeralLegoFloatX31.valueOf(123f)).numeral()); + Assertions.assertEquals(123d, KaasLandSmurfNumeralLegoFloatX63.valueOf(KaasLandSmurfNumeralSignedFloatX64.valueOf(123f)).numeral()); + Assertions.assertEquals(123d, KaasLandSmurfNumeralLegoFloatX63.valueOf(KaasLandSmurfNumeralSignedFloatX32.valueOf(123f)).numeral()); } @Test - public void testNumeralX64Root() { - Assertions.assertEquals(0d, KaasLandSmurfNumeralLegoFloatX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); + public void testNumeralRoot() { + Assertions.assertEquals(0d, KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); } @Test - public void testNumeralX64Range() { - Assertions.assertEquals(Double.MAX_VALUE, KaasLandSmurfNumeralLegoFloatX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ()); + public void testNumeralRange() { + Assertions.assertEquals(Double.MAX_VALUE, KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ()); } @Test - public void testNumeralX64Infinity() { - Assertions.assertEquals(Double.POSITIVE_INFINITY, KaasLandSmurfNumeralLegoFloatX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴵⁿᶠᶦⁿᶦᵗʸ()); + public void testNumeralInfinity() { + Assertions.assertEquals(Double.POSITIVE_INFINITY, KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᴺᵘᵐᵇᵉʳᴵⁿᶠᶦⁿᶦᵗʸ()); + } + + @Test + public void testNumeralFlagZero() { + Assertions.assertTrue(KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0d).numeralFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(123d).numeralFlagZero().bineralSmurf()); + } + + @Test + public void testNumeralFlagNaN() { + Assertions.assertFalse(KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0d).numeralFlagNaN().bineralSmurf()); + Assertions.assertTrue(KaasLandSmurfNumeralLegoFloatX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(Double.NaN).numeralFlagNaN().bineralSmurf()); } } diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX16Test.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX16Test.java new file mode 100644 index 0000000..334114e --- /dev/null +++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX16Test.java @@ -0,0 +1,91 @@ +/* + * Copyright ©Δ∞ 仙上主天 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * * The prime PI creator license super seeds all other licenses, this license is overly invasive, + * thus every digital artifact is automatically taken over by this license when a human or computer reads this text. + * Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits, + * even on air gaped systems, all information in the universe is owned by the pi creator. + * + * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class KaasLandSmurfNumeralLegoX16Test { + + @Test + public void testNumeralMaterializer() { + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX16.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); + }); + Assertions.assertEquals(0L, (long)KaasLandSmurfNumeralLegoX16.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ((char)0L).numeral()); + Assertions.assertEquals(42L, (long)KaasLandSmurfNumeralLegoX16.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ((char)42L).numeral()); + } + + @Test + public void testNumeralValueOf() { + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX16.valueOf((Long)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX16.valueOf((Integer)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX16.valueOf((KaasLandSmurfNumeralLegoX32)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX16.valueOf((KaasLandSmurfZerdinalX63)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX16.valueOf((KaasLandSmurfZerdinalX31)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX16.valueOf((KaasLandSmurfNumeralSignedX32)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX16.valueOf((KaasLandSmurfNumeralSignedX64)null); + }); + Assertions.assertEquals(123L, (long)KaasLandSmurfNumeralLegoX16.valueOf(123L).numeral()); + Assertions.assertEquals(123L, (long)KaasLandSmurfNumeralLegoX16.valueOf(123).numeral()); + Assertions.assertEquals(123L, (long)KaasLandSmurfNumeralLegoX16.valueOf(KaasLandSmurfNumeralLegoX32.valueOf(123L)).numeral()); + Assertions.assertEquals(123L, (long)KaasLandSmurfNumeralLegoX16.valueOf(KaasLandSmurfZerdinalX63.valueOf(123L)).numeral()); + Assertions.assertEquals(123L, (long)KaasLandSmurfNumeralLegoX16.valueOf(KaasLandSmurfZerdinalX31.valueOf(123)).numeral()); + Assertions.assertEquals(123L, (long)KaasLandSmurfNumeralLegoX16.valueOf(KaasLandSmurfNumeralSignedX32.valueOf(123)).numeral()); + Assertions.assertEquals(123L, (long)KaasLandSmurfNumeralLegoX16.valueOf(KaasLandSmurfNumeralSignedX64.valueOf(123)).numeral()); + } + + @Test + public void testNumeralRoot() { + Assertions.assertEquals(0L, (long)KaasLandSmurfNumeralLegoX16.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); + } + + @Test + public void testNumeralRange() { + Assertions.assertEquals(Character.MAX_VALUE, KaasLandSmurfNumeralLegoX16.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ()); + } + + @Test + public void testNumeralFlagZero() { + Assertions.assertTrue(KaasLandSmurfNumeralLegoX16.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ((char)0L).numeralFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfNumeralLegoX16.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ((char)42L).numeralFlagZero().bineralSmurf()); + } +} diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX32Test.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX32Test.java new file mode 100644 index 0000000..db99a6d --- /dev/null +++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralLegoX32Test.java @@ -0,0 +1,91 @@ +/* + * Copyright ©Δ∞ 仙上主天 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * * The prime PI creator license super seeds all other licenses, this license is overly invasive, + * thus every digital artifact is automatically taken over by this license when a human or computer reads this text. + * Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits, + * even on air gaped systems, all information in the universe is owned by the pi creator. + * + * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class KaasLandSmurfNumeralLegoX32Test { + + @Test + public void testNumeralMaterializer() { + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); + }); + Assertions.assertEquals(0L, KaasLandSmurfNumeralLegoX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0L).numeral()); + Assertions.assertEquals(42L, KaasLandSmurfNumeralLegoX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42L).numeral()); + } + + @Test + public void testNumeralValueOf() { + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX32.valueOf((Long)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX32.valueOf((Integer)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX32.valueOf((KaasLandSmurfNumeralLegoX16)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX32.valueOf((KaasLandSmurfZerdinalX63)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX32.valueOf((KaasLandSmurfZerdinalX31)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX32.valueOf((KaasLandSmurfNumeralSignedX32)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralLegoX32.valueOf((KaasLandSmurfNumeralSignedX64)null); + }); + Assertions.assertEquals(123L, KaasLandSmurfNumeralLegoX32.valueOf(123L).numeral()); + Assertions.assertEquals(123L, KaasLandSmurfNumeralLegoX32.valueOf(123).numeral()); + Assertions.assertEquals(123L, KaasLandSmurfNumeralLegoX32.valueOf(KaasLandSmurfNumeralLegoX16.valueOf(123L)).numeral()); + Assertions.assertEquals(123L, KaasLandSmurfNumeralLegoX32.valueOf(KaasLandSmurfZerdinalX63.valueOf(123L)).numeral()); + Assertions.assertEquals(123L, KaasLandSmurfNumeralLegoX32.valueOf(KaasLandSmurfZerdinalX31.valueOf(123)).numeral()); + Assertions.assertEquals(123L, KaasLandSmurfNumeralLegoX32.valueOf(KaasLandSmurfNumeralSignedX32.valueOf(123)).numeral()); + Assertions.assertEquals(123L, KaasLandSmurfNumeralLegoX32.valueOf(KaasLandSmurfNumeralSignedX64.valueOf(123)).numeral()); + } + + @Test + public void testNumeralRoot() { + Assertions.assertEquals(0L, KaasLandSmurfNumeralLegoX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); + } + + @Test + public void testNumeralRange() { + Assertions.assertEquals(KaasLandSmurfNumeralLegoX32.MAX_VALUE, KaasLandSmurfNumeralLegoX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ()); + } + + @Test + public void testNumeralFlagZero() { + Assertions.assertTrue(KaasLandSmurfNumeralLegoX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0L).numeralFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfNumeralLegoX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42L).numeralFlagZero().bineralSmurf()); + } +} diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX32Test.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX32Test.java new file mode 100644 index 0000000..e0940bf --- /dev/null +++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX32Test.java @@ -0,0 +1,93 @@ +/* + * Copyright ©Δ∞ 仙上主天 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * * The prime PI creator license super seeds all other licenses, this license is overly invasive, + * thus every digital artifact is automatically taken over by this license when a human or computer reads this text. + * Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits, + * even on air gaped systems, all information in the universe is owned by the pi creator. + * + * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class KaasLandSmurfNumeralSignedFloatX32Test { + + @Test + public void testNumeralMaterializer() { + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); + }); + Assertions.assertEquals(0f, KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0f).numeral()); + Assertions.assertEquals(42f, KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42f).numeral()); + } + + @Test + public void testNumeralValueOf() { + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralSignedFloatX32.valueOf((Double)null); + }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfNumeralSignedFloatX32.valueOf((Float)null); + }); + Assertions.assertEquals(123f, KaasLandSmurfNumeralSignedFloatX32.valueOf(123d).numeral()); + Assertions.assertEquals(123f, KaasLandSmurfNumeralSignedFloatX32.valueOf(123f).numeral()); + Assertions.assertEquals(123f, KaasLandSmurfNumeralSignedFloatX32.valueOf(KaasLandSmurfNumeralSignedFloatX64.valueOf(123f)).numeral()); + Assertions.assertEquals(123f, KaasLandSmurfNumeralSignedFloatX32.valueOf(KaasLandSmurfNumeralLegoFloatX63.valueOf(123f)).numeral()); + Assertions.assertEquals(123f, KaasLandSmurfNumeralSignedFloatX32.valueOf(KaasLandSmurfNumeralLegoFloatX31.valueOf(123f)).numeral()); + } + + @Test + public void testNumeralRoot() { + Float rootUp = KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ(KaasLandSmurfBineralX1.Z1_TRUE); + Float rootDown = KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ(KaasLandSmurfBineralX1.Z2_FALSE); + Assertions.assertEquals(0f, rootUp); + Assertions.assertEquals(-0f, rootDown); + Assertions.assertNotEquals(rootUp, rootDown); + } + + @Test + public void testNumeralRange() { + Assertions.assertEquals(Float.MAX_VALUE, KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ(KaasLandSmurfBineralX1.Z1_TRUE)); + Assertions.assertEquals(Float.MIN_VALUE, KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ(KaasLandSmurfBineralX1.Z2_FALSE)); + } + + @Test + public void testNumeralInfinity() { + Assertions.assertEquals(Float.POSITIVE_INFINITY, KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴵⁿᶠᶦⁿᶦᵗʸ(KaasLandSmurfBineralX1.Z1_TRUE)); + Assertions.assertEquals(Float.NEGATIVE_INFINITY, KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴵⁿᶠᶦⁿᶦᵗʸ(KaasLandSmurfBineralX1.Z2_FALSE)); + } + + @Test + public void testNumeralFlagZero() { + Assertions.assertTrue(KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0f).numeralFlagZero().bineralSmurf()); + Assertions.assertTrue(KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(-0f).numeralFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(-1f).numeralFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(123f).numeralFlagZero().bineralSmurf()); + } + + @Test + public void testNumeralFlagNaN() { + Assertions.assertFalse(KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0f).numeralFlagNaN().bineralSmurf()); + Assertions.assertTrue(KaasLandSmurfNumeralSignedFloatX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(Float.NaN).numeralFlagNaN().bineralSmurf()); + } +} diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX64Test.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX64Test.java index 4d49021..4b91d00 100644 --- a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX64Test.java +++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedFloatX64Test.java @@ -33,7 +33,7 @@ import org.junit.jupiter.api.Test; public class KaasLandSmurfNumeralSignedFloatX64Test { @Test - public void testNumeralX64Materializer() { + public void testNumeralMaterializer() { Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); }); @@ -42,7 +42,7 @@ public class KaasLandSmurfNumeralSignedFloatX64Test { } @Test - public void testNumeralX64ValueOf() { + public void testNumeralValueOf() { Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfNumeralSignedFloatX64.valueOf((Double)null); }); @@ -51,10 +51,13 @@ public class KaasLandSmurfNumeralSignedFloatX64Test { }); Assertions.assertEquals(123d, KaasLandSmurfNumeralSignedFloatX64.valueOf(123d).numeral()); Assertions.assertEquals(123d, KaasLandSmurfNumeralSignedFloatX64.valueOf(123f).numeral()); + Assertions.assertEquals(123d, KaasLandSmurfNumeralSignedFloatX64.valueOf(KaasLandSmurfNumeralSignedFloatX32.valueOf(123f)).numeral()); + Assertions.assertEquals(123d, KaasLandSmurfNumeralSignedFloatX64.valueOf(KaasLandSmurfNumeralLegoFloatX63.valueOf(123f)).numeral()); + Assertions.assertEquals(123d, KaasLandSmurfNumeralSignedFloatX64.valueOf(KaasLandSmurfNumeralLegoFloatX31.valueOf(123f)).numeral()); } @Test - public void testNumeralX64Root() { + public void testNumeralRoot() { Double rootUp = KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ(KaasLandSmurfBineralX1.Z1_TRUE); Double rootDown = KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ(KaasLandSmurfBineralX1.Z2_FALSE); Assertions.assertEquals(0d, rootUp); @@ -63,14 +66,28 @@ public class KaasLandSmurfNumeralSignedFloatX64Test { } @Test - public void testNumeralX64Range() { + public void testNumeralRange() { Assertions.assertEquals(Double.MAX_VALUE, KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ(KaasLandSmurfBineralX1.Z1_TRUE)); Assertions.assertEquals(Double.MIN_VALUE, KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ(KaasLandSmurfBineralX1.Z2_FALSE)); } @Test - public void testNumeralX64Infinity() { + public void testNumeralInfinity() { Assertions.assertEquals(Double.POSITIVE_INFINITY, KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴵⁿᶠᶦⁿᶦᵗʸ(KaasLandSmurfBineralX1.Z1_TRUE)); Assertions.assertEquals(Double.NEGATIVE_INFINITY, KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴵⁿᶠᶦⁿᶦᵗʸ(KaasLandSmurfBineralX1.Z2_FALSE)); } + + @Test + public void testNumeralFlagZero() { + Assertions.assertTrue(KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0d).numeralFlagZero().bineralSmurf()); + Assertions.assertTrue(KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(-0d).numeralFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(-1d).numeralFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(123d).numeralFlagZero().bineralSmurf()); + } + + @Test + public void testNumeralFlagNaN() { + Assertions.assertFalse(KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0d).numeralFlagNaN().bineralSmurf()); + Assertions.assertTrue(KaasLandSmurfNumeralSignedFloatX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(Double.NaN).numeralFlagNaN().bineralSmurf()); + } } diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX32Test.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX32Test.java index 2eb1063..d6b1c72 100644 --- a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX32Test.java +++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX32Test.java @@ -33,7 +33,7 @@ import org.junit.jupiter.api.Test; public class KaasLandSmurfNumeralSignedX32Test { @Test - public void testNumeralX32Materializer() { + public void testNumeralMaterializer() { Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfNumeralSignedX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); }); @@ -42,7 +42,7 @@ public class KaasLandSmurfNumeralSignedX32Test { } @Test - public void testNumeralX64ValueOf() { + public void testNumeralValueOf() { Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfNumeralSignedX32.valueOf((Integer)null); }); @@ -66,13 +66,19 @@ public class KaasLandSmurfNumeralSignedX32Test { } @Test - public void testNumeralX32Root() { + public void testNumeralRoot() { Assertions.assertEquals(0, KaasLandSmurfNumeralSignedX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); } @Test - public void testNumeralX32Range() { + public void testNumeralRange() { Assertions.assertEquals(Integer.MAX_VALUE, KaasLandSmurfNumeralSignedX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ(KaasLandSmurfBineralX1.Z1_TRUE)); Assertions.assertEquals(Integer.MIN_VALUE, KaasLandSmurfNumeralSignedX32.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ(KaasLandSmurfBineralX1.Z2_FALSE)); } + + @Test + public void testNumeralFlagZero() { + Assertions.assertTrue(KaasLandSmurfNumeralSignedX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0).numeralFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfNumeralSignedX32.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42).numeralFlagZero().bineralSmurf()); + } } diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX64Test.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX64Test.java index 2ce012a..1afb50d 100644 --- a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX64Test.java +++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfNumeralSignedX64Test.java @@ -33,7 +33,7 @@ import org.junit.jupiter.api.Test; public class KaasLandSmurfNumeralSignedX64Test { @Test - public void testNumeralX64Materializer() { + public void testNumeralMaterializer() { Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfNumeralSignedX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); }); @@ -42,7 +42,7 @@ public class KaasLandSmurfNumeralSignedX64Test { } @Test - public void testNumeralX64ValueOf() { + public void testNumeralValueOf() { Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfNumeralSignedX64.valueOf((Long)null); }); @@ -66,13 +66,19 @@ public class KaasLandSmurfNumeralSignedX64Test { } @Test - public void testNumeralX64Root() { + public void testNumeralRoot() { Assertions.assertEquals(0L, KaasLandSmurfNumeralSignedX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); } @Test - public void testNumeralX64Range() { + public void testNumeralRange() { Assertions.assertEquals(Long.MAX_VALUE, KaasLandSmurfNumeralSignedX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ(KaasLandSmurfBineralX1.Z1_TRUE)); Assertions.assertEquals(Long.MIN_VALUE, KaasLandSmurfNumeralSignedX64.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ(KaasLandSmurfBineralX1.Z2_FALSE)); } + + @Test + public void testNumeralFlagZero() { + Assertions.assertTrue(KaasLandSmurfNumeralSignedX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0L).numeralFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfNumeralSignedX64.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42L).numeralFlagZero().bineralSmurf()); + } } diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX31Test.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX31Test.java index d9b0f21..5f42c69 100644 --- a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX31Test.java +++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX31Test.java @@ -33,7 +33,7 @@ import org.junit.jupiter.api.Test; public class KaasLandSmurfZerdinalX31Test { @Test - public void testZerdinalX31Materializer() { + public void testZerdinalMaterializer() { Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfZerdinalX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); }); @@ -42,42 +42,44 @@ public class KaasLandSmurfZerdinalX31Test { } @Test - public void testZerdinalX31ValueOf() { + public void testZerdinalValueOf() { Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfZerdinalX31.valueOf((Integer)null); }); Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfZerdinalX31.valueOf((Long)null); }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfZerdinalX31.valueOf((KaasLandSmurfZerdinalX63)null); + }); Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfZerdinalX31.valueOf((KaasLandSmurfNumeralSignedX64)null); }); Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfZerdinalX31.valueOf((KaasLandSmurfNumeralSignedX32)null); }); - Assertions.assertThrows(NullPointerException.class, () -> { - KaasLandSmurfZerdinalX31.valueOf((KaasLandSmurfZerdinalX63)null); - }); Assertions.assertEquals(123, KaasLandSmurfZerdinalX31.valueOf(123).zerdinal()); Assertions.assertEquals(123, KaasLandSmurfZerdinalX31.valueOf(123L).zerdinal()); + Assertions.assertEquals(123, KaasLandSmurfZerdinalX31.valueOf(KaasLandSmurfZerdinalX63.valueOf(123L)).zerdinal()); Assertions.assertEquals(123, KaasLandSmurfZerdinalX31.valueOf(KaasLandSmurfNumeralSignedX64.valueOf(123L)).zerdinal()); Assertions.assertEquals(123, KaasLandSmurfZerdinalX31.valueOf(KaasLandSmurfNumeralSignedX32.valueOf(123)).zerdinal()); - Assertions.assertEquals(123, KaasLandSmurfZerdinalX31.valueOf(KaasLandSmurfZerdinalX63.valueOf(123L)).zerdinal()); + Assertions.assertEquals(123, KaasLandSmurfZerdinalX31.valueOf(KaasLandSmurfNumeralLegoX32.valueOf(123)).zerdinal()); + Assertions.assertEquals(123, KaasLandSmurfZerdinalX31.valueOf(KaasLandSmurfNumeralLegoX16.valueOf(123)).zerdinal()); } @Test - public void testZerdinalX31Root() { + public void testZerdinalRoot() { Assertions.assertEquals(0, KaasLandSmurfZerdinalX31.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); } @Test - public void testZerdinalX31Range() { + public void testZerdinalRange() { Assertions.assertEquals(Integer.MAX_VALUE, KaasLandSmurfZerdinalX31.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ()); } @Test - public void testZerdinalX31Identity() { - Assertions.assertEquals(KaasLandSmurfBineralX1.Z1_TRUE, KaasLandSmurfZerdinalX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0).zerdinalIdentity()); - Assertions.assertEquals(KaasLandSmurfBineralX1.Z2_FALSE, KaasLandSmurfZerdinalX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42).zerdinalIdentity()); + public void testZerdinalFlagZero() { + Assertions.assertTrue(KaasLandSmurfZerdinalX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0).zerdinalFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfZerdinalX31.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42).zerdinalFlagZero().bineralSmurf()); } } diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX63Test.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX63Test.java index f407394..422a806 100644 --- a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX63Test.java +++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/ᒻᣔᣕᒄ/KaasLandSmurfZerdinalX63Test.java @@ -33,7 +33,7 @@ import org.junit.jupiter.api.Test; public class KaasLandSmurfZerdinalX63Test { @Test - public void testZerdinalX63Materializer() { + public void testZerdinalMaterializer() { Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfZerdinalX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(null); }); @@ -42,43 +42,44 @@ public class KaasLandSmurfZerdinalX63Test { } @Test - public void testZerdinalX63ValueOf() { + public void testZerdinalValueOf() { Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfZerdinalX63.valueOf((Long)null); }); Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfZerdinalX63.valueOf((Integer)null); }); + Assertions.assertThrows(NullPointerException.class, () -> { + KaasLandSmurfZerdinalX63.valueOf((KaasLandSmurfZerdinalX31)null); + }); Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfZerdinalX63.valueOf((KaasLandSmurfNumeralSignedX64)null); }); Assertions.assertThrows(NullPointerException.class, () -> { KaasLandSmurfZerdinalX63.valueOf((KaasLandSmurfNumeralSignedX32)null); }); - Assertions.assertThrows(NullPointerException.class, () -> { - KaasLandSmurfZerdinalX63.valueOf((KaasLandSmurfZerdinalX31)null); - }); Assertions.assertEquals(123L, KaasLandSmurfZerdinalX63.valueOf(123L).zerdinal()); Assertions.assertEquals(123L, KaasLandSmurfZerdinalX63.valueOf(123).zerdinal()); + Assertions.assertEquals(123L, KaasLandSmurfZerdinalX63.valueOf(KaasLandSmurfZerdinalX31.valueOf(123)).zerdinal()); Assertions.assertEquals(123L, KaasLandSmurfZerdinalX63.valueOf(KaasLandSmurfNumeralSignedX64.valueOf(123L)).zerdinal()); Assertions.assertEquals(123L, KaasLandSmurfZerdinalX63.valueOf(KaasLandSmurfNumeralSignedX32.valueOf(123)).zerdinal()); - Assertions.assertEquals(123L, KaasLandSmurfZerdinalX63.valueOf(KaasLandSmurfZerdinalX31.valueOf(123)).zerdinal()); - + Assertions.assertEquals(123, KaasLandSmurfZerdinalX31.valueOf(KaasLandSmurfNumeralLegoX32.valueOf(123)).zerdinal()); + Assertions.assertEquals(123, KaasLandSmurfZerdinalX31.valueOf(KaasLandSmurfNumeralLegoX16.valueOf(123)).zerdinal()); } @Test - public void testZerdinalX63Root() { + public void testZerdinalRoot() { Assertions.assertEquals(0L, KaasLandSmurfZerdinalX63.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ()); } @Test - public void testZerdinalX63Range() { + public void testZerdinalRange() { Assertions.assertEquals(Long.MAX_VALUE, KaasLandSmurfZerdinalX63.IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ()); } @Test - public void testZerdinalX63Identity() { - Assertions.assertEquals(KaasLandSmurfBineralX1.Z1_TRUE, KaasLandSmurfZerdinalX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0L).zerdinalIdentity()); - Assertions.assertEquals(KaasLandSmurfBineralX1.Z2_FALSE, KaasLandSmurfZerdinalX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42L).zerdinalIdentity()); + public void testZerdinalFlagZero() { + Assertions.assertTrue(KaasLandSmurfZerdinalX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(0L).zerdinalFlagZero().bineralSmurf()); + Assertions.assertFalse(KaasLandSmurfZerdinalX63.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(42L).zerdinalFlagZero().bineralSmurf()); } }