From 54cd6e30d929feaa14b38a9e9e1bf6f9c55ebdf3 Mon Sep 17 00:00:00 2001 From: Oskars AA <66279792+Krumuvecis@users.noreply.github.com> Date: Tue, 28 Jun 2022 20:57:55 +0300 Subject: [PATCH 1/5] version number update --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 2ee8425..93184a8 100644 --- a/pom.xml +++ b/pom.xml @@ -6,7 +6,7 @@ com.github.Krumuvecis PreciseValues - 0.2 + 0.3 UTF-8 From f3e7c4db3851e753adf0ceeeac90080950e85cf9 Mon Sep 17 00:00:00 2001 From: Oskars AA <66279792+Krumuvecis@users.noreply.github.com> Date: Tue, 28 Jun 2022 21:16:16 +0300 Subject: [PATCH 2/5] readme --- ReadMe.md | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 ReadMe.md diff --git a/ReadMe.md b/ReadMe.md new file mode 100644 index 0000000..c233ce9 --- /dev/null +++ b/ReadMe.md @@ -0,0 +1,45 @@ +# Precise Values + +[![](https://jitpack.io/v/Krumuvecis/PreciseValues.svg)](https://jitpack.io/#Krumuvecis/PreciseValues) + +by [Krumuvecis](https://github.com/Krumuvecis) + +Free to use and modify for whatever purposes. No copyrights apply. + + +## Abstract + +This is mainly a library for a new data type `PreciseNumber`, but also has other functionality. + + +### PreciseNumber + +A new data type representing value +/- error [like this](https://www2.southeastern.edu/Academics/Faculty/rallain/plab194/error.html). + +`PreciseNumber` consists of 2 parts: +* `BigDecimal` value part; +* `NumberError` error part, which further consists of 2 parts: + * `BigDecimal` value of the error; + * `ErrorType` type of the error (enum). + + +### Other functionality + +A list of functions: +* *something* +* *somethingsomething* +* *somethingsomethingmore* +* ... + + +## Requirements + +* JDK: 18 +* Maven compiler: 18 +* Maven Surefire: 3.0.0-M7 +* jetbrains annotations: 23.0.0 + + +## Notes + +*Under construction, expect changes...* From b8cd693962030d09bfda8778afcd1cb3280a9749 Mon Sep 17 00:00:00 2001 From: Oskars AA <66279792+Krumuvecis@users.noreply.github.com> Date: Wed, 29 Jun 2022 00:53:37 +0300 Subject: [PATCH 3/5] work on intermediary members --- .../lists/AbstractPrimitivePrecisionList.java | 52 +++++++++++- .../lists/IntermediaryMember.java | 73 +++++++++++++++++ .../UndefinedPrecisionPrimitiveList.java | 81 +------------------ 3 files changed, 124 insertions(+), 82 deletions(-) create mode 100644 src/main/java/preciseValues/lists/IntermediaryMember.java diff --git a/src/main/java/preciseValues/lists/AbstractPrimitivePrecisionList.java b/src/main/java/preciseValues/lists/AbstractPrimitivePrecisionList.java index 12f5531..430a6fd 100644 --- a/src/main/java/preciseValues/lists/AbstractPrimitivePrecisionList.java +++ b/src/main/java/preciseValues/lists/AbstractPrimitivePrecisionList.java @@ -2,6 +2,8 @@ import preciseValues.errorModel.NumberError; +import java.math.MathContext; +import java.math.RoundingMode; import java.util.List; import java.util.ArrayList; import java.util.Objects; @@ -12,10 +14,19 @@ //TODO: add javadoc public abstract class AbstractPrimitivePrecisionList extends AbstractPrecisionList { - public List members; + boolean calculated; + public List members; public AbstractPrimitivePrecisionList(@Nullable List members) { - this.members = Objects.requireNonNullElse(members, new ArrayList<>()); + calculated = false; + setMembers(Objects.requireNonNullElse(members, new ArrayList<>())); + } + + private void setMembers(@NotNull List members) { + this.members = new ArrayList<>(); + for (double member : members) { + this.members.add(new IntermediaryMember(member)); + } } //prevents further overriding @@ -32,11 +43,44 @@ public final int getMemberCount() { @Override public final @NotNull BigDecimal getMemberSum() { BigDecimal sum = new BigDecimal(0); - for (double member : members) { - sum = sum.add(new BigDecimal(member)); + for (IntermediaryMember member : members) { + sum = sum.add(member.getValue()); + } + return sum; + } + + /* + private BigDecimal getStandardDeviation(BigDecimal average, + List intermediaryMembers) { + BigDecimal sumOfSquaredOffsets = getSumOfSquaredOffsets(average, intermediaryMembers); + + int memberCount = getMemberCount(); // N + int divisor; + if (memberCount > 1) { + divisor = memberCount - 1; // N - 1 + } else { + divisor = 1; + } + + return (sumOfSquaredOffsets.divide( + new BigDecimal(divisor), + RoundingMode.HALF_UP) + ).sqrt(new MathContext( + sumOfSquaredOffsets.precision() / 2, + RoundingMode.HALF_UP)); + } + */ + + /* + private BigDecimal getSumOfSquaredOffsets(BigDecimal average, + List intermediaryMembers) { + BigDecimal sum = BigDecimal.ZERO; + for (IntermediaryMember intermediaryMember : intermediaryMembers) { + sum = sum.add(intermediaryMember.offsetSquared(average)); } return sum; } + */ @Override public abstract @NotNull NumberError getAbsoluteError(); diff --git a/src/main/java/preciseValues/lists/IntermediaryMember.java b/src/main/java/preciseValues/lists/IntermediaryMember.java new file mode 100644 index 0000000..5dca38c --- /dev/null +++ b/src/main/java/preciseValues/lists/IntermediaryMember.java @@ -0,0 +1,73 @@ +package preciseValues.lists; + +import java.math.BigDecimal; +import java.math.MathContext; +import java.math.RoundingMode; + +import org.jetbrains.annotations.NotNull; + +/** + * TODO: finish this + */ +public class IntermediaryMember { + private BigDecimal value, offset, offsetSquared; + private boolean discrepancy; + + public IntermediaryMember(double value) { + setValue(value); + } + + private void setValue(double value) { + this.value = new BigDecimal(String.valueOf(value)); + } + + //TODO: add javadoc + public @NotNull BigDecimal getValue() { + return value; + } + + /** + * Call this to calculate offsets. + * TODO: finish this javadoc + * + * @param average Average value for reference. + */ + public void setOffsets(@NotNull BigDecimal average) { + setOffset(average); + setOffsetSquared(); + } + + //delta + private void setOffset(@NotNull BigDecimal average) { + this.offset = value.subtract( + average, + new MathContext(average.precision())); + } + + //delta squared + private void setOffsetSquared() { + int power = 2; + offsetSquared = offset.pow( + power, + new MathContext(power * offset.precision())); + } + + //TODO: add javadoc + public @NotNull BigDecimal getOffsetSquared() { + return offsetSquared; + } + + //TODO: add javadoc + public void setDiscrepancy(@NotNull BigDecimal standardDeviation, + @NotNull BigDecimal coefficient) { + this.discrepancy = (this.offset.abs()).divide( + standardDeviation, + RoundingMode.HALF_UP + ).compareTo(coefficient) > 0; + } + + //TODO: add javadoc + public boolean getDiscrepancy() { + return discrepancy; + } +} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/UndefinedPrecisionPrimitiveList.java b/src/main/java/preciseValues/lists/UndefinedPrecisionPrimitiveList.java index ffc4449..bfe3fe5 100644 --- a/src/main/java/preciseValues/lists/UndefinedPrecisionPrimitiveList.java +++ b/src/main/java/preciseValues/lists/UndefinedPrecisionPrimitiveList.java @@ -4,104 +4,29 @@ import preciseValues.errorModel.NumberError; import java.util.List; -import java.util.ArrayList; -import java.math.BigDecimal; -import java.math.MathContext; -import java.math.RoundingMode; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; //TODO: finish this and add javadoc public class UndefinedPrecisionPrimitiveList extends AbstractPrimitivePrecisionList { - public UndefinedPrecisionPrimitiveList(@Nullable List members) { super(members); } - static class IntermediaryMember { - final double value; - - IntermediaryMember(double value) { - this.value = value; - } - - //delta - BigDecimal offset(BigDecimal average) { - return (new BigDecimal(value)).subtract( - average, - new MathContext(average.precision())); - } - - //delta squared - BigDecimal offsetSquared(BigDecimal average) { - int power = 2; - return offset(average).pow( - power, - new MathContext(power * (average.precision()))); - } - - boolean determineDiscrepancy(BigDecimal average, - BigDecimal standardDeviation, - BigDecimal coefficient) { - return (offset(average).abs()).divide( - standardDeviation, - RoundingMode.HALF_UP - ).compareTo(coefficient) > 0; - } - } - @Override public final @NotNull NumberError getAbsoluteError() { - List intermediaryMembers = initializeIntermediaryMembers(); - //TODO: finish this System.err.println("Unfinished functionality:" + "\n" + "UndefinedPrecisionPrimitiveList.getAbsoluteError() returns null, where annotated as not-null!"); return null; } - private List initializeIntermediaryMembers() { - List intermediaryMembers = new ArrayList<>(); - for (double member : members) { - intermediaryMembers.add(new IntermediaryMember(member)); - } - return intermediaryMembers; - } - - private BigDecimal getStandardDeviation(BigDecimal average, - List intermediaryMembers) { - BigDecimal sumOfSquaredOffsets = getSumOfSquaredOffsets(average, intermediaryMembers); - - int memberCount = getMemberCount(); // N - int divisor; - if (memberCount > 1) { - divisor = memberCount - 1; // N - 1 - } else { - divisor = 1; - } - - return (sumOfSquaredOffsets.divide( - new BigDecimal(divisor), - RoundingMode.HALF_UP) - ).sqrt(new MathContext( - sumOfSquaredOffsets.precision() / 2, - RoundingMode.HALF_UP)); - } - - private BigDecimal getSumOfSquaredOffsets(BigDecimal average, - List intermediaryMembers) { - BigDecimal sum = BigDecimal.ZERO; - for (IntermediaryMember intermediaryMember : intermediaryMembers) { - sum = sum.add(intermediaryMember.offsetSquared(average)); - } - return sum; - } - @Override public final @NotNull NumberError getRelativeError() { + ErrorType errorType = ErrorType.RELATIVE; return new NumberError( - ErrorType.RELATIVE, - getAbsoluteError().getError(ErrorType.RELATIVE, getAverage())); + errorType, + getAbsoluteError().getError(errorType, getAverage())); } } \ No newline at end of file From 5324dd4dc20cefc0316fe68143a4e612cdd46cf3 Mon Sep 17 00:00:00 2001 From: Oskars AA <66279792+Krumuvecis@users.noreply.github.com> Date: Thu, 30 Jun 2022 23:06:04 +0300 Subject: [PATCH 4/5] rework --- .../preciseValues/errorModel/NumberError.java | 27 +++-- .../preciseValues/lists/AbstractPList.java | 114 ++++++++++++++++++ .../lists/AbstractPrecisionList.java | 52 -------- .../lists/AbstractPrimitivePrecisionList.java | 90 -------------- .../lists/CommonPrecisionPrimitiveList.java | 36 ------ .../lists/IntermediaryMember.java | 73 ----------- src/main/java/preciseValues/lists/PList.java | 96 +++++++++++++++ ...ListInterface.java => PListInterface.java} | 9 +- .../java/preciseValues/lists/PListMember.java | 97 +++++++++++++++ .../preciseValues/lists/PrecisionList.java | 57 --------- .../UndefinedPrecisionPrimitiveList.java | 32 ----- .../lists/WeightedPrecisionList.java | 57 --------- src/main/java/preciseValues/lists/doc.md | 20 +++ .../PNumber.java} | 8 +- src/test/java/listTest/Main.java | 105 ++++++++++++++++ src/test/java/main/PrecisionTest.java | 113 ----------------- 16 files changed, 460 insertions(+), 526 deletions(-) create mode 100644 src/main/java/preciseValues/lists/AbstractPList.java delete mode 100644 src/main/java/preciseValues/lists/AbstractPrecisionList.java delete mode 100644 src/main/java/preciseValues/lists/AbstractPrimitivePrecisionList.java delete mode 100644 src/main/java/preciseValues/lists/CommonPrecisionPrimitiveList.java delete mode 100644 src/main/java/preciseValues/lists/IntermediaryMember.java create mode 100644 src/main/java/preciseValues/lists/PList.java rename src/main/java/preciseValues/lists/{PrecisionListInterface.java => PListInterface.java} (58%) create mode 100644 src/main/java/preciseValues/lists/PListMember.java delete mode 100644 src/main/java/preciseValues/lists/PrecisionList.java delete mode 100644 src/main/java/preciseValues/lists/UndefinedPrecisionPrimitiveList.java delete mode 100644 src/main/java/preciseValues/lists/WeightedPrecisionList.java create mode 100644 src/main/java/preciseValues/lists/doc.md rename src/main/java/preciseValues/{preciseNumber/PreciseNumber.java => pNumber/PNumber.java} (84%) create mode 100644 src/test/java/listTest/Main.java delete mode 100644 src/test/java/main/PrecisionTest.java diff --git a/src/main/java/preciseValues/errorModel/NumberError.java b/src/main/java/preciseValues/errorModel/NumberError.java index 40663d5..8fdafb4 100644 --- a/src/main/java/preciseValues/errorModel/NumberError.java +++ b/src/main/java/preciseValues/errorModel/NumberError.java @@ -11,6 +11,7 @@ * TODO: finish this javadoc */ public class NumberError { + public static final NumberError NON_NULL_ERROR = new NumberError(); private static final BigDecimal UNDEFINED_ERROR_VALUE = new BigDecimal(0), NON_NULL_AVERAGE_VALUE = new BigDecimal(0); @@ -65,37 +66,45 @@ public NumberError(@Nullable ErrorType errorType, @Nullable BigDecimal errorValu * @param errorType Type of error to return. * @param averageValue Average value for reference. * - * @return Value of the error. + * @return Error of the desired type. */ - public final @NotNull BigDecimal getError( + public final @NotNull NumberError getError( @Nullable ErrorType errorType, @Nullable BigDecimal averageValue) { return switch (Objects.requireNonNullElse(errorType, ErrorType.UNDEFINED)) { case ABSOLUTE -> getAbsoluteError(averageValue); case RELATIVE -> getRelativeError(averageValue); - default -> UNDEFINED_ERROR_VALUE; + default -> NON_NULL_ERROR; }; } - private @NotNull BigDecimal getAbsoluteError(@Nullable BigDecimal averageValue) { + private @NotNull NumberError getAbsoluteError(@Nullable BigDecimal averageValue) { + return new NumberError(ErrorType.ABSOLUTE, getAbsoluteErrorValue(averageValue)); + } + + private @NotNull BigDecimal getAbsoluteErrorValue(@Nullable BigDecimal averageValue) { return switch (errorType) { case ABSOLUTE -> errorValue; - case RELATIVE -> getAbsoluteFromRelative( + case RELATIVE -> getAbsoluteValueFromRelativeValue( errorValue, Objects.requireNonNullElse(averageValue, NON_NULL_AVERAGE_VALUE)); default -> UNDEFINED_ERROR_VALUE; }; } - private static @NotNull BigDecimal getAbsoluteFromRelative( + private static @NotNull BigDecimal getAbsoluteValueFromRelativeValue( @NotNull BigDecimal errorValue, @NotNull BigDecimal averageValue) { return averageValue.multiply(errorValue); } - private @NotNull BigDecimal getRelativeError(@Nullable BigDecimal averageValue) { + private @NotNull NumberError getRelativeError(@Nullable BigDecimal averageValue) { + return new NumberError(ErrorType.RELATIVE, getRelativeErrorValue(averageValue)); + } + + private @NotNull BigDecimal getRelativeErrorValue(@Nullable BigDecimal averageValue) { return switch (errorType) { - case ABSOLUTE -> getRelativeFromAbsolute( + case ABSOLUTE -> getRelativeValueFromAbsoluteValue( errorValue, Objects.requireNonNullElse(averageValue, NON_NULL_AVERAGE_VALUE)); case RELATIVE -> errorValue; @@ -103,7 +112,7 @@ public NumberError(@Nullable ErrorType errorType, @Nullable BigDecimal errorValu }; } - private static @NotNull BigDecimal getRelativeFromAbsolute( + private static @NotNull BigDecimal getRelativeValueFromAbsoluteValue( @NotNull BigDecimal errorValue, @NotNull BigDecimal averageValue) { BigDecimal result; diff --git a/src/main/java/preciseValues/lists/AbstractPList.java b/src/main/java/preciseValues/lists/AbstractPList.java new file mode 100644 index 0000000..7ea0e28 --- /dev/null +++ b/src/main/java/preciseValues/lists/AbstractPList.java @@ -0,0 +1,114 @@ +package preciseValues.lists; + +import preciseValues.errorModel.ErrorType; +import preciseValues.errorModel.NumberError; +import preciseValues.pNumber.PNumber; + +import java.util.List; +import java.util.ArrayList; +import java.util.Objects; +import java.math.BigDecimal; +import java.math.RoundingMode; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +//TODO: add javadoc +public abstract class AbstractPList implements PListInterface { + + public List startingList, resultList; + public boolean calculated; + + private BigDecimal average; + private BigDecimal standardDeviation; + + //TODO: add javadoc + AbstractPList(@Nullable List members) { + calculated = false; + startingList = List.copyOf(Objects.requireNonNullElse(members, new ArrayList<>())); + } + + //TODO: finish this and add javadoc + @Override + public void calculate(BigDecimal probability) { + resultList = List.copyOf(startingList); + setAverage(); + setOffsets(); + setStandardDeviation(); + //TODO: get discrepancies + //TODO: repeat + calculated = true; + } + + //TODO: add javadoc + public final int getStartingMemberCount() { + return startingList.size(); + } + + //TODO: add javadoc + @Override + public final int getMemberCount() { + return resultList.size(); + } + + //TODO: add javadoc + public void setAverage() { + this.average = getMemberSum().divide( + new BigDecimal(getMemberCount()), + RoundingMode.HALF_UP); + } + + private @NotNull BigDecimal getMemberSum() { + BigDecimal sum = BigDecimal.ZERO; + for (PListMember member : resultList) { + sum = sum.add(member.getValue().getValue()); + } + return sum; + } + + private void setOffsets() { + BigDecimal average = getAverage(); + for (PListMember member : resultList) { + member.setOffsets(average); + } + } + + private void setStandardDeviation() { + //TODO: finish this + this.standardDeviation = null; + } + + //TODO: add javadoc + @SuppressWarnings("unused") + public final @NotNull BigDecimal getStandardDeviation() { + return standardDeviation; + } + + //TODO: add javadoc + @Override + public final @NotNull BigDecimal getAverage() { + return average; + } + + //TODO: add javadoc + @Override + public final @NotNull NumberError getError(@Nullable ErrorType errorType) { + return switch(Objects.requireNonNullElse(errorType, ErrorType.UNDEFINED)) { + case ABSOLUTE -> getAbsoluteError(); + case RELATIVE -> getRelativeError(); + default -> NumberError.NON_NULL_ERROR; + }; + } + + //TODO: add javadoc + public abstract @NotNull NumberError getAbsoluteError(); + + //TODO: add javadoc + public abstract @NotNull NumberError getRelativeError(); + + //TODO: add javadoc + @Override + public final @NotNull PNumber getAverage(@Nullable ErrorType errorType) { + return new PNumber(getAverage(), getError(errorType)); + } +} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/AbstractPrecisionList.java b/src/main/java/preciseValues/lists/AbstractPrecisionList.java deleted file mode 100644 index 77ed0fa..0000000 --- a/src/main/java/preciseValues/lists/AbstractPrecisionList.java +++ /dev/null @@ -1,52 +0,0 @@ -package preciseValues.lists; - -import preciseValues.errorModel.ErrorType; -import preciseValues.errorModel.NumberError; -import preciseValues.preciseNumber.PreciseNumber; - -import java.util.Objects; -import java.math.BigDecimal; -import java.math.RoundingMode; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -//TODO: add javadoc -abstract class AbstractPrecisionList implements PrecisionListInterface { - @Override - public final @NotNull PreciseNumber getAverage(@Nullable ErrorType errorType) { - return new PreciseNumber(getAverage(), getError(errorType)); - } - - @Override - public @NotNull BigDecimal getAverage() { - BigDecimal undefinedMemberSum = BigDecimal.ZERO; - BigDecimal memberSum = Objects.requireNonNullElse(getMemberSum(), undefinedMemberSum); - - BigDecimal result; - try { - result = memberSum.divide(new BigDecimal(getMemberCount()), RoundingMode.HALF_UP); - } catch (ArithmeticException e) { - System.err.println("BigDecimal - trying to divide by zero or insufficient scaling."); - result = memberSum; // Returns sum in such case. - } - return result; - } - - public abstract int getMemberCount(); - - public abstract @NotNull BigDecimal getMemberSum(); - - @Override - public final @NotNull NumberError getError(@Nullable ErrorType errorType) { - return switch (Objects.requireNonNullElse(errorType, ErrorType.UNDEFINED)) { - case ABSOLUTE -> getAbsoluteError(); - case RELATIVE -> getRelativeError(); - default -> new NumberError(); - }; - } - - public abstract @NotNull NumberError getAbsoluteError(); - - public abstract @NotNull NumberError getRelativeError(); -} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/AbstractPrimitivePrecisionList.java b/src/main/java/preciseValues/lists/AbstractPrimitivePrecisionList.java deleted file mode 100644 index 430a6fd..0000000 --- a/src/main/java/preciseValues/lists/AbstractPrimitivePrecisionList.java +++ /dev/null @@ -1,90 +0,0 @@ -package preciseValues.lists; - -import preciseValues.errorModel.NumberError; - -import java.math.MathContext; -import java.math.RoundingMode; -import java.util.List; -import java.util.ArrayList; -import java.util.Objects; -import java.math.BigDecimal; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -//TODO: add javadoc -public abstract class AbstractPrimitivePrecisionList extends AbstractPrecisionList { - boolean calculated; - public List members; - - public AbstractPrimitivePrecisionList(@Nullable List members) { - calculated = false; - setMembers(Objects.requireNonNullElse(members, new ArrayList<>())); - } - - private void setMembers(@NotNull List members) { - this.members = new ArrayList<>(); - for (double member : members) { - this.members.add(new IntermediaryMember(member)); - } - } - - //prevents further overriding - @Override - public final @NotNull BigDecimal getAverage() { - return super.getAverage(); - } - - @Override - public final int getMemberCount() { - return members.size(); - } - - @Override - public final @NotNull BigDecimal getMemberSum() { - BigDecimal sum = new BigDecimal(0); - for (IntermediaryMember member : members) { - sum = sum.add(member.getValue()); - } - return sum; - } - - /* - private BigDecimal getStandardDeviation(BigDecimal average, - List intermediaryMembers) { - BigDecimal sumOfSquaredOffsets = getSumOfSquaredOffsets(average, intermediaryMembers); - - int memberCount = getMemberCount(); // N - int divisor; - if (memberCount > 1) { - divisor = memberCount - 1; // N - 1 - } else { - divisor = 1; - } - - return (sumOfSquaredOffsets.divide( - new BigDecimal(divisor), - RoundingMode.HALF_UP) - ).sqrt(new MathContext( - sumOfSquaredOffsets.precision() / 2, - RoundingMode.HALF_UP)); - } - */ - - /* - private BigDecimal getSumOfSquaredOffsets(BigDecimal average, - List intermediaryMembers) { - BigDecimal sum = BigDecimal.ZERO; - for (IntermediaryMember intermediaryMember : intermediaryMembers) { - sum = sum.add(intermediaryMember.offsetSquared(average)); - } - return sum; - } - */ - - @Override - public abstract @NotNull NumberError getAbsoluteError(); - - @Override - public abstract @NotNull NumberError getRelativeError(); -} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/CommonPrecisionPrimitiveList.java b/src/main/java/preciseValues/lists/CommonPrecisionPrimitiveList.java deleted file mode 100644 index 797845e..0000000 --- a/src/main/java/preciseValues/lists/CommonPrecisionPrimitiveList.java +++ /dev/null @@ -1,36 +0,0 @@ -package preciseValues.lists; - -import preciseValues.errorModel.NumberError; - -import java.util.List; -import java.util.Objects; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -//TODO: finish this and add javadoc -public class CommonPrecisionPrimitiveList extends AbstractPrimitivePrecisionList { - public NumberError commonPrecision; - - public CommonPrecisionPrimitiveList(@Nullable NumberError precision, - @Nullable List members) { - super(members); - this.commonPrecision = Objects.requireNonNullElse(precision, new NumberError()); - } - - @Override - public final @NotNull NumberError getAbsoluteError() { - //TODO: finish this - System.err.println("Unfinished functionality:" + "\n" - + "CommonPrecisionPrimitiveList.getAbsoluteError() returns null, where annotated as not-null!"); - return null; - } - - @Override - public final @NotNull NumberError getRelativeError() { - //TODO: finish this - System.err.println("Unfinished functionality:" + "\n" - + "CommonPrecisionPrimitiveList.getRelativeError() returns null, where annotated as not-null!"); - return null; - } -} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/IntermediaryMember.java b/src/main/java/preciseValues/lists/IntermediaryMember.java deleted file mode 100644 index 5dca38c..0000000 --- a/src/main/java/preciseValues/lists/IntermediaryMember.java +++ /dev/null @@ -1,73 +0,0 @@ -package preciseValues.lists; - -import java.math.BigDecimal; -import java.math.MathContext; -import java.math.RoundingMode; - -import org.jetbrains.annotations.NotNull; - -/** - * TODO: finish this - */ -public class IntermediaryMember { - private BigDecimal value, offset, offsetSquared; - private boolean discrepancy; - - public IntermediaryMember(double value) { - setValue(value); - } - - private void setValue(double value) { - this.value = new BigDecimal(String.valueOf(value)); - } - - //TODO: add javadoc - public @NotNull BigDecimal getValue() { - return value; - } - - /** - * Call this to calculate offsets. - * TODO: finish this javadoc - * - * @param average Average value for reference. - */ - public void setOffsets(@NotNull BigDecimal average) { - setOffset(average); - setOffsetSquared(); - } - - //delta - private void setOffset(@NotNull BigDecimal average) { - this.offset = value.subtract( - average, - new MathContext(average.precision())); - } - - //delta squared - private void setOffsetSquared() { - int power = 2; - offsetSquared = offset.pow( - power, - new MathContext(power * offset.precision())); - } - - //TODO: add javadoc - public @NotNull BigDecimal getOffsetSquared() { - return offsetSquared; - } - - //TODO: add javadoc - public void setDiscrepancy(@NotNull BigDecimal standardDeviation, - @NotNull BigDecimal coefficient) { - this.discrepancy = (this.offset.abs()).divide( - standardDeviation, - RoundingMode.HALF_UP - ).compareTo(coefficient) > 0; - } - - //TODO: add javadoc - public boolean getDiscrepancy() { - return discrepancy; - } -} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/PList.java b/src/main/java/preciseValues/lists/PList.java new file mode 100644 index 0000000..0da3b8b --- /dev/null +++ b/src/main/java/preciseValues/lists/PList.java @@ -0,0 +1,96 @@ +package preciseValues.lists; + +import preciseValues.pNumber.PNumber; +import preciseValues.errorModel.ErrorType; +import preciseValues.errorModel.NumberError; + +import java.util.List; +import java.util.ArrayList; +import java.util.Objects; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * TODO: + * * finish this + * * finish this javadoc + * * add javadoc to members + */ +public class PList extends AbstractPList { + public PList(@Nullable List members) { + super(prepareStartingMembers(members)); + } + + private static @NotNull List prepareStartingMembers(@Nullable List members) { + List nonNullList = Objects.requireNonNullElse(members, new ArrayList<>()); + List startingList = new ArrayList<>(); + if (!nonNullList.isEmpty()) { + T firstMember = nonNullList.get(0); + if (firstMember instanceof Double) { + for (T member : nonNullList) { + startingList.add(new PListMember((double) member)); + } + } else if (firstMember instanceof PNumber) { + for (T member : nonNullList) { + startingList.add(new PListMember((PNumber) member)); + } + } + } + return startingList; + } + + public PList(NumberError commonError, List members) { + super(prepareStartingMembers(commonError, members)); + } + + private static @NotNull List prepareStartingMembers(NumberError commonError, + @Nullable List members) { + List startingList = new ArrayList<>(); + for (double member : Objects.requireNonNullElse(members, new ArrayList())) { + startingList.add(new PListMember(member, commonError)); + } + return startingList; + } + + /* + public PList(@Nullable List members) { + super(prepareStartingMembers(members)); + } + + private static @NotNull List prepareStartingMembers(@Nullable List members) { + List startingList = new ArrayList<>(); + for (PNumber member : Objects.requireNonNullElse(members, new ArrayList())) { + startingList.add(new PListMember(member)); + } + return startingList; + } + + public PList(Map weightedMembers) { + super(prepareStartingMembers(weightedMembers)); + } + + private static @NotNull List prepareStartingMembers(@Nullable Map weightedMembers) { + List startingList = new ArrayList<>(); + Map nonNullMap = Objects.requireNonNullElse(weightedMembers, new HashMap<>()); + for (PNumber member : nonNullMap.keySet()) { + int weight = nonNullMap.get(member); + startingList.add(new PListMember(member, weight)); + } + return startingList; + } + */ + + //TODO: add javadoc + @Override + public @NotNull NumberError getAbsoluteError() { + //TODO: finish this + return null; + } + + //TODO: add javadoc + @Override + public @NotNull NumberError getRelativeError() { + return getAbsoluteError().getError(ErrorType.RELATIVE, getAverage()); + } +} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/PrecisionListInterface.java b/src/main/java/preciseValues/lists/PListInterface.java similarity index 58% rename from src/main/java/preciseValues/lists/PrecisionListInterface.java rename to src/main/java/preciseValues/lists/PListInterface.java index d1c2094..0708e93 100644 --- a/src/main/java/preciseValues/lists/PrecisionListInterface.java +++ b/src/main/java/preciseValues/lists/PListInterface.java @@ -2,7 +2,7 @@ import preciseValues.errorModel.ErrorType; import preciseValues.errorModel.NumberError; -import preciseValues.preciseNumber.PreciseNumber; +import preciseValues.pNumber.PNumber; import java.math.BigDecimal; @@ -10,8 +10,11 @@ import org.jetbrains.annotations.Nullable; //TODO: add javadoc -interface PrecisionListInterface { - @NotNull PreciseNumber getAverage(@Nullable ErrorType errorType); +//is this interface actually necessary? +interface PListInterface { + void calculate(BigDecimal probability); + int getMemberCount(); @NotNull BigDecimal getAverage(); @NotNull NumberError getError(@Nullable ErrorType errorType); + @NotNull PNumber getAverage(@Nullable ErrorType errorType); //average + error } \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/PListMember.java b/src/main/java/preciseValues/lists/PListMember.java new file mode 100644 index 0000000..d7a99f2 --- /dev/null +++ b/src/main/java/preciseValues/lists/PListMember.java @@ -0,0 +1,97 @@ +package preciseValues.lists; + +import preciseValues.errorModel.NumberError; +import preciseValues.pNumber.PNumber; + +import java.util.Objects; +import java.math.BigDecimal; +import java.math.MathContext; +import java.math.RoundingMode; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +//TODO: add javadoc +public class PListMember { + private static final PNumber NON_NULL_P_NUMBER = new PNumber(null, null); + + private final PNumber value; + private final int weight; + + private BigDecimal offset, offsetSquared; // delta and delta squared + private boolean discrepancy; + + //for lists with undefined precision + public PListMember(double value) { + this(value, NumberError.NON_NULL_ERROR); + } + + //for lists with commonly defined precision + public PListMember(double value, @Nullable NumberError commonError) { + this(new PNumber( + new BigDecimal(String.valueOf(value)), + Objects.requireNonNullElse(commonError, NumberError.NON_NULL_ERROR))); + } + + //for lists with individually defined precision + public PListMember(@Nullable PNumber value) { + this(value, 1); + } + + //for weighted lists + public PListMember(@Nullable PNumber value, int weight) { + this.value = Objects.requireNonNullElse(value, NON_NULL_P_NUMBER); + this.weight = weight; + } + + public @NotNull PNumber getValue() { + return value; + } + + public int getWeight() { + return weight; + } + + /** + * Call this to calculate offsets. + * TODO: finish this javadoc + * + * @param average Average value for reference. + */ + public void setOffsets(@NotNull BigDecimal average) { + setOffset(average); + setOffsetSquared(); + } + + private void setOffset(@NotNull BigDecimal average) { + this.offset = value.getValue().subtract( + average, + new MathContext(average.precision())); + } + + private void setOffsetSquared() { + int power = 2; + offsetSquared = offset.pow( + power, + new MathContext(power * offset.precision())); + } + + //TODO: add javadoc + public @NotNull BigDecimal getOffsetSquared() { + return offsetSquared; + } + + //TODO: add javadoc + public void setDiscrepancy(@NotNull BigDecimal standardDeviation, + @NotNull BigDecimal studentCoefficient) { + this.discrepancy = (this.offset.abs()).divide( + standardDeviation, + RoundingMode.HALF_UP + ).compareTo(studentCoefficient) > 0; + } + + //TODO: add javadoc + public boolean getDiscrepancy() { + return discrepancy; + } +} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/PrecisionList.java b/src/main/java/preciseValues/lists/PrecisionList.java deleted file mode 100644 index f315e1d..0000000 --- a/src/main/java/preciseValues/lists/PrecisionList.java +++ /dev/null @@ -1,57 +0,0 @@ -package preciseValues.lists; - -import preciseValues.errorModel.NumberError; -import preciseValues.preciseNumber.PreciseNumber; - -import java.util.List; -import java.util.ArrayList; -import java.util.Objects; -import java.math.BigDecimal; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -//TODO: finish this and add javadoc -public class PrecisionList extends AbstractPrecisionList { - public List members; - - public PrecisionList(@Nullable ArrayList members) { - this.members = Objects.requireNonNullElse(members, new ArrayList<>()); - } - - //prevents further overriding - @Override - public final @NotNull BigDecimal getAverage() { - return super.getAverage(); - } - - @Override - public final int getMemberCount() { - return members.size(); - } - - @Override - public final @NotNull BigDecimal getMemberSum() { - BigDecimal sum = new BigDecimal(0); - for (PreciseNumber member : members) { - sum = sum.add(member.getValue()); - } - return sum; - } - - @Override - public @NotNull NumberError getAbsoluteError() { - //TODO: finish this - System.err.println("Unfinished functionality:" + "\n" - + "PrecisionList.getAbsoluteError() returns null, where annotated as not-null!"); - return null; - } - - @Override - public @NotNull NumberError getRelativeError() { - //TODO: finish this - System.err.println("Unfinished functionality:" + "\n" - + "PrecisionList.getRelativeError() returns null, where annotated as not-null!"); - return null; - } -} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/UndefinedPrecisionPrimitiveList.java b/src/main/java/preciseValues/lists/UndefinedPrecisionPrimitiveList.java deleted file mode 100644 index bfe3fe5..0000000 --- a/src/main/java/preciseValues/lists/UndefinedPrecisionPrimitiveList.java +++ /dev/null @@ -1,32 +0,0 @@ -package preciseValues.lists; - -import preciseValues.errorModel.ErrorType; -import preciseValues.errorModel.NumberError; - -import java.util.List; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -//TODO: finish this and add javadoc -public class UndefinedPrecisionPrimitiveList extends AbstractPrimitivePrecisionList { - public UndefinedPrecisionPrimitiveList(@Nullable List members) { - super(members); - } - - @Override - public final @NotNull NumberError getAbsoluteError() { - //TODO: finish this - System.err.println("Unfinished functionality:" + "\n" - + "UndefinedPrecisionPrimitiveList.getAbsoluteError() returns null, where annotated as not-null!"); - return null; - } - - @Override - public final @NotNull NumberError getRelativeError() { - ErrorType errorType = ErrorType.RELATIVE; - return new NumberError( - errorType, - getAbsoluteError().getError(errorType, getAverage())); - } -} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/WeightedPrecisionList.java b/src/main/java/preciseValues/lists/WeightedPrecisionList.java deleted file mode 100644 index 7fc2202..0000000 --- a/src/main/java/preciseValues/lists/WeightedPrecisionList.java +++ /dev/null @@ -1,57 +0,0 @@ -package preciseValues.lists; - -import preciseValues.errorModel.NumberError; -import preciseValues.preciseNumber.PreciseNumber; - -import java.math.BigDecimal; -import java.util.Map; -import java.util.HashMap; -import java.util.Objects; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -//TODO: finish this and add javadoc -public class WeightedPrecisionList extends AbstractPrecisionList { - public Map members; - - public WeightedPrecisionList(@Nullable HashMap members) { - this.members = Objects.requireNonNullElse(members, new HashMap<>()); - } - - @Override - public final @NotNull BigDecimal getAverage() { - //TODO: finish this - return null; - } - - @Override - public final int getMemberCount() { - return members.size(); - } - - @Override - public final @NotNull BigDecimal getMemberSum() { - BigDecimal sum = new BigDecimal(0); - for (PreciseNumber member : members.keySet()) { - sum = sum.add(member.getValue()); - } - return sum; - } - - @Override - public @NotNull NumberError getAbsoluteError() { - //TODO: finish this - System.err.println("Unfinished functionality:" + "\n" - + "PrecisionList.getAbsoluteError() returns null, where annotated as not-null!"); - return null; - } - - @Override - public @NotNull NumberError getRelativeError() { - //TODO: finish this - System.err.println("Unfinished functionality:" + "\n" - + "PrecisionList.getRelativeError() returns null, where annotated as not-null!"); - return null; - } -} \ No newline at end of file diff --git a/src/main/java/preciseValues/lists/doc.md b/src/main/java/preciseValues/lists/doc.md new file mode 100644 index 0000000..b2bd6a5 --- /dev/null +++ b/src/main/java/preciseValues/lists/doc.md @@ -0,0 +1,20 @@ +# Precision Lists + +## Abstract + +Lists for precisely calculating averages, distributions, etc. + + +## List types + +1. List of doubles +2. List of doubles with common precision +3. List of PreciseNumber containing individual precisions +4. Weighted list of PreciseNumber - `Map` + + +## Common functionality + +* `getMemberCount` +* `getAverage` +* *etc...* \ No newline at end of file diff --git a/src/main/java/preciseValues/preciseNumber/PreciseNumber.java b/src/main/java/preciseValues/pNumber/PNumber.java similarity index 84% rename from src/main/java/preciseValues/preciseNumber/PreciseNumber.java rename to src/main/java/preciseValues/pNumber/PNumber.java index e3a7d74..152d61f 100644 --- a/src/main/java/preciseValues/preciseNumber/PreciseNumber.java +++ b/src/main/java/preciseValues/pNumber/PNumber.java @@ -1,4 +1,4 @@ -package preciseValues.preciseNumber; +package preciseValues.pNumber; import preciseValues.errorModel.NumberError; @@ -11,9 +11,9 @@ /** * TODO: finish this javadoc */ -public class PreciseNumber { +public class PNumber { private static final BigDecimal UNDEFINED_VALUE = BigDecimal.ZERO; - private static final NumberError UNDEFINED_ERROR = new NumberError(); + private static final NumberError UNDEFINED_ERROR = NumberError.NON_NULL_ERROR; private BigDecimal value; private NumberError error; @@ -24,7 +24,7 @@ public class PreciseNumber { * @param value Value part of the number. * @param error Error part of the number. */ - public PreciseNumber(@Nullable BigDecimal value, @Nullable NumberError error) { + public PNumber(@Nullable BigDecimal value, @Nullable NumberError error) { setValue(value); setError(error); } diff --git a/src/test/java/listTest/Main.java b/src/test/java/listTest/Main.java new file mode 100644 index 0000000..388fc33 --- /dev/null +++ b/src/test/java/listTest/Main.java @@ -0,0 +1,105 @@ +package listTest; + +import preciseValues.errorModel.ErrorType; +import preciseValues.errorModel.NumberError; +import preciseValues.pNumber.PNumber; +import preciseValues.lists.PList; + +import java.util.ArrayList; +import java.math.BigDecimal; + +//TODO: finish this and add javadoc +public class Main { + static PList list1, list2, list3, list4; //see doc.md for numbering explanation + + /** + * The main method. + * Launch this and watch magic happen. + * + * @param args args + */ + public static void main(String[] args) { + initializeLists(); + output(); + } + + private static void initializeLists() { + NumberError commonError = getCommonError(); + preparePrimitiveLists(commonError); + preparePreciseLists(commonError); + } + + private static NumberError getCommonError() { + return new NumberError(ErrorType.ABSOLUTE, new BigDecimal("0.5")); + } + + private static void preparePrimitiveLists(NumberError commonError) { + ArrayList primitivesList = getPrimitivesList(); + list1 = new PList(primitivesList); + list1 = new PList(commonError, primitivesList); + } + + private static ArrayList getPrimitivesList() { + return new ArrayList<>() {{ + add(5.1); + add(5.2); + add(5.3); + add(5.4); + add(5.5); + }}; + } + + private static void preparePreciseLists(NumberError commonError) { + list3 = new PList(new ArrayList<>() {{ + add(new PNumber(new BigDecimal("5.1"), commonError)); + add(new PNumber(new BigDecimal("5.2"), commonError)); + add(new PNumber(new BigDecimal("5.3"), commonError)); + add(new PNumber(new BigDecimal("5.4"), commonError)); + add(new PNumber(new BigDecimal("5.5"), commonError)); + }}); + + /* + list4 = new PList(new HashMap<>() {{ + put(new PNumber(new BigDecimal("5.1"), commonError), 1); + put(new PNumber(new BigDecimal("5.2"), commonError), 1); + put(new PNumber(new BigDecimal("5.3"), commonError), 1); + put(new PNumber(new BigDecimal("5.4"), commonError), 1); + put(new PNumber(new BigDecimal("5.5"), commonError), 1); + }});*/ + } + + private static void output() { + sectionSeparator(); + printLine("Testing a PList of doubles with undefined precision."); + //printLine("Average : " + list1.getAverage()); + //printLine("Absolute error : " + list1.getAverage(ErrorType.ABSOLUTE).getError().getErrorValue()); + //printLine("Relative error : " + list1.getAverage(ErrorType.RELATIVE).getError().getErrorValue() + " %"); + + sectionSeparator(); + printLine("Testing a PList of doubles with common precision."); + //printLine("Average : " + list2.getAverage()); + //printLine("Absolute error : " + list2.getAverage(ErrorType.ABSOLUTE).getError().getErrorValue()); + //printLine("Relative error : " + list2.getAverage(ErrorType.RELATIVE).getError().getErrorValue() + " %"); + + sectionSeparator(); + printLine("Testing a PList with individually defined precision."); + //printLine("Average : " + list3.getAverage()); + //printLine("Absolute error : " + list3.getAverage(ErrorType.ABSOLUTE).getError().getErrorValue()); + //printLine("Relative error : " + list3.getAverage(ErrorType.RELATIVE).getError().getErrorValue() + " %"); + + sectionSeparator(); + //printLine("Testing a weighted PList."); + //printLine("Average : " + list4.getAverage()); + //printLine("Absolute error : " + list4.getAverage(ErrorType.ABSOLUTE).getError().getErrorValue()); + //printLine("Relative error : " + list4.getAverage(ErrorType.RELATIVE).getError().getErrorValue() + " %"); + } + + private static void printLine(String line) { + System.out.println(line); + } + + private static void sectionSeparator() { + String separator = "------------"; + printLine(separator); + } +} \ No newline at end of file diff --git a/src/test/java/main/PrecisionTest.java b/src/test/java/main/PrecisionTest.java deleted file mode 100644 index d4b18f8..0000000 --- a/src/test/java/main/PrecisionTest.java +++ /dev/null @@ -1,113 +0,0 @@ -package main; - -import preciseValues.errorModel.ErrorType; -import preciseValues.errorModel.NumberError; -import preciseValues.preciseNumber.PreciseNumber; -import preciseValues.lists.UndefinedPrecisionPrimitiveList; -import preciseValues.lists.CommonPrecisionPrimitiveList; -import preciseValues.lists.PrecisionList; -import preciseValues.lists.WeightedPrecisionList; - -import java.math.BigDecimal; -import java.util.ArrayList; -import java.util.HashMap; - -//TODO: finish this and add javadoc -public class PrecisionTest { - static UndefinedPrecisionPrimitiveList undefinedPrecisionPrimitiveList; - static CommonPrecisionPrimitiveList commonPrecisionPrimitiveList; - static PrecisionList precisionList; - static WeightedPrecisionList weightedPrecisionList; - - /** - * The main method. - * Launch this and watch magic happen. - * - * @param args args - */ - public static void main(String[] args) { - initializeLists(); - output(); - } - - private static void initializeLists() { - NumberError commonError = getCommonError(); - preparePrimitiveLists(commonError); - preparePreciseLists(commonError); - } - - private static NumberError getCommonError() { - return new NumberError(ErrorType.ABSOLUTE, new BigDecimal("0.5")); - } - - private static void preparePrimitiveLists(NumberError commonError) { - ArrayList primitivesList = getPrimitivesList(); - undefinedPrecisionPrimitiveList = - new UndefinedPrecisionPrimitiveList(primitivesList); - commonPrecisionPrimitiveList = - new CommonPrecisionPrimitiveList(commonError, primitivesList); - } - - private static ArrayList getPrimitivesList() { - return new ArrayList<>() {{ - add(5.1); - add(5.2); - add(5.3); - add(5.4); - add(5.5); - }}; - } - - private static void preparePreciseLists(NumberError commonError) { - precisionList = new PrecisionList(new ArrayList<>() {{ - add(new PreciseNumber(new BigDecimal("5.1"), commonError)); - add(new PreciseNumber(new BigDecimal("5.2"), commonError)); - add(new PreciseNumber(new BigDecimal("5.3"), commonError)); - add(new PreciseNumber(new BigDecimal("5.4"), commonError)); - add(new PreciseNumber(new BigDecimal("5.5"), commonError)); - }}); - - weightedPrecisionList = new WeightedPrecisionList(new HashMap<>() {{ - put(new PreciseNumber(new BigDecimal("5.1"), commonError), 1); - put(new PreciseNumber(new BigDecimal("5.2"), commonError), 1); - put(new PreciseNumber(new BigDecimal("5.3"), commonError), 1); - put(new PreciseNumber(new BigDecimal("5.4"), commonError), 1); - put(new PreciseNumber(new BigDecimal("5.5"), commonError), 1); - }}); - } - - private static void output() { - sectionSeparator(); - printLine("Testing UndefinedPrecisionPrimitiveList"); - printLine("Average : " + undefinedPrecisionPrimitiveList.getAverage()); - //printLine("Absolute error : " + undefinedPrecisionPrimitiveList.getAverage(ErrorType.ABSOLUTE).getError().getErrorValue()); - //printLine("Relative error : " + undefinedPrecisionPrimitiveList.getAverage(ErrorType.RELATIVE).getError().getErrorValue() + " %"); - - sectionSeparator(); - printLine("Testing CommonPrecisionPrimitiveList"); - printLine("Average : " + commonPrecisionPrimitiveList.getAverage()); - //printLine("Absolute error : " + commonPrecisionPrimitiveList.getAverage(ErrorType.ABSOLUTE).getError().getErrorValue()); - //printLine("Relative error : " + commonPrecisionPrimitiveList.getAverage(ErrorType.RELATIVE).getError().getErrorValue() + " %"); - - sectionSeparator(); - printLine("Testing PrecisionList"); - printLine("Average : " + precisionList.getAverage()); - //printLine("Absolute error : " + precisionList.getAverage(ErrorType.ABSOLUTE).getError().getErrorValue()); - //printLine("Relative error : " + precisionList.getAverage(ErrorType.RELATIVE).getError().getErrorValue() + " %"); - - sectionSeparator(); - printLine("Testing WeightedPrecisionList"); - //printLine("Average : " + weightedPrecisionList.getAverage()); - //printLine("Absolute error : " + weightedPrecisionList.getAverage(ErrorType.ABSOLUTE).getError().getErrorValue()); - //printLine("Relative error : " + weightedPrecisionList.getAverage(ErrorType.RELATIVE).getError().getErrorValue() + " %"); - } - - private static void printLine(String line) { - System.out.println(line); - } - - private static void sectionSeparator() { - String separator = "------------"; - printLine(separator); - } -} \ No newline at end of file From 464a9df62ffbf4d6c0aa6d3b0b1ca5b071d13bf4 Mon Sep 17 00:00:00 2001 From: Oskars AA <66279792+Krumuvecis@users.noreply.github.com> Date: Mon, 4 Jul 2022 16:21:59 +0300 Subject: [PATCH 5/5] migration --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 93184a8..84ce6bd 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 4.0.0 - com.github.Krumuvecis + com.github.KruMF PreciseValues 0.3