From 8175042b4a6583d603297a8cf36c7c55f14e2d46 Mon Sep 17 00:00:00 2001 From: Hubert Tylkowski Date: Wed, 27 Jun 2018 11:16:10 +0200 Subject: [PATCH] changed error handling --- 02-Wielomiany/out/production/Main.class | Bin 2317 -> 2626 bytes .../out/production/PolynomialTask.class | Bin 6951 -> 4190 bytes 02-Wielomiany/src/META-INF/MANIFEST.MF | 3 + 02-Wielomiany/src/Main.java | 10 +- 02-Wielomiany/src/PolynomialTask.java | 190 ++++++++++-------- 5 files changed, 113 insertions(+), 90 deletions(-) create mode 100644 02-Wielomiany/src/META-INF/MANIFEST.MF diff --git a/02-Wielomiany/out/production/Main.class b/02-Wielomiany/out/production/Main.class index 7e1d69c1b6067ec66632039da6c0d9664622eec3..d27faa036f697c465501d7f202492a5f4d66c766 100644 GIT binary patch delta 1198 zcmZ{i%X1WU5XV2iePou&FWF@i5~9RJG@69ONDQb%5rTq5LJ||?6~IY$4I4K*OLi8G zs3R!8L1oZ`2dgX(R#|0HSmg$#$^%FK6K)(hTl8;-M`Fnwy8GL|?r%S)&!w+5`q%&c z`yXI{A8a0Bi_IV}SiEQxHDD_*8L=(FcB6-EcJOjq;)iQ_jXh};!xnpO>KI+c7~=_E zx0ztlVxLXgP}K2;vGyl8V8B5m4jIqk1XFfW>K!p$M=g$7ym|T9Miu;`{Mt6!Ega1> zGeK`;t)J0kc}p|PaYd|Ws?@E?F=z3%CeOSgHRQTp$y;!WBU$gbn<*u0D5P*j6;qth zEKsuWG-XbT?;S<`n44cLxbrzDKk1Z&r;T?l7B%m2N}�ys!Cy6N=`!A?Kvimv;)Y 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 literal 6951 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 sQC$&L;VdDza*6j7V3B$!{> firstPolynomial = new ArrayList<>(); args[1] = args[1].substring(1, args[1].length()-1); @@ -14,6 +13,11 @@ public class Main { List secondPolynomial = new ArrayList<>(); Arrays.asList(args[2].split(",\\s*" )).forEach(factor -> secondPolynomial.add(Integer.valueOf(factor))); PolynomialTask polynomialTask = new PolynomialTask(n, firstPolynomial, secondPolynomial); - polynomialTask.printAllValuesToStandardOutput(); + System.out.print("["); + System.out.print(polynomialTask.printMultipliedPoly() + + ", " + polynomialTask.printSubtractedPoly() + + ", " + polynomialTask.printGcd()); + System.out.print("]"); + } } diff --git a/02-Wielomiany/src/PolynomialTask.java b/02-Wielomiany/src/PolynomialTask.java index 1370891..8fd7fb3 100644 --- a/02-Wielomiany/src/PolynomialTask.java +++ b/02-Wielomiany/src/PolynomialTask.java @@ -1,134 +1,150 @@ -import java.util.ArrayList; import java.util.Arrays; -import java.util.Collections; import java.util.List; -import java.util.stream.Collectors; public class PolynomialTask { private int n; - private List firstPolynomial; - private List secondPolynomial; + private int[] firstPolynomialAsArray; + private int[] secondPolynomialAsArray; public PolynomialTask(int n, List firstPoly, List secondPoly) { this.n = n; - this.firstPolynomial = firstPoly; - this.secondPolynomial = secondPoly; + this.firstPolynomialAsArray = parseListToArray(firstPoly); + this.secondPolynomialAsArray = parseListToArray(secondPoly); } - public Integer[] multiplyPolynomials(List firstPolynomial, List secondPolynomial) { - int[] multiplied = new int[firstPolynomial.size() + secondPolynomial.size() - 1]; - int sizeOfFirstPoly = firstPolynomial.size(); - int sizeOfSecondPoly = secondPolynomial.size(); + private int[] parseListToArray(List polynomial) { + int[] result = new int[polynomial.size()]; + for (int i = 0; i < polynomial.size(); i++) { + result[i] = polynomial.get(i); + } + return result; + } + + private int[] multiplyPolynomials(int[] firstPolynomial, int[] secondPolynomial) { + int[] multiplied = new int[firstPolynomial.length + secondPolynomial.length - 1]; + int sizeOfFirstPoly = firstPolynomial.length; + int sizeOfSecondPoly = secondPolynomial.length; for (int i = 0; i < sizeOfFirstPoly; i++) { for (int j = 0; j < sizeOfSecondPoly; j++) - multiplied[i + j] = (multiplied[i + j] + (firstPolynomial.get(i) * secondPolynomial.get(j))) % n; + multiplied[i + j] = (multiplied[i + j] + (firstPolynomial[i] * secondPolynomial[j])) % n; } - return Arrays.stream(multiplied).boxed().toArray(Integer[]::new); + return multiplied; } - public int[] moduloDividePolynomialsReturnQuotient(List firstPoly, List secondPoly) throws MultiplierNotFoundException, DivisionErrorException { - int[] quotient = new int[firstPoly.size() + secondPoly.size()]; - int firstPolyDegree = firstPoly.size() - 1; - int secondPolyDegree = secondPoly.size() - 1; - List polynomialAfterSubtract = firstPoly; - - - while (firstPolyDegree >= secondPolyDegree) { - polynomialAfterSubtract = calcQuotient(polynomialAfterSubtract, secondPoly, quotient); - firstPolyDegree = polynomialAfterSubtract.size() - 1; + private int[] polyDiv(int[] polyOne, int[] polyTwo) { + if (polyOne.length < polyTwo.length) { + return null; } - - int[] remainder = new int[polynomialAfterSubtract.size()]; - for (int i = 0; i < polynomialAfterSubtract.size(); i++) { - remainder[i] = polynomialAfterSubtract.get(i); + int firstPolyDeg = polyOne.length - 1; + int secondPolyDeg = polyTwo.length - 1; + int[] tempArr = new int[polyOne.length]; + int[] result; + fillTemporaryArray(polyTwo, tempArr); + int tempMultiplier; + int shift = 0; + while (firstPolyDeg >= secondPolyDeg) { + parseNegativeElement(polyOne, firstPolyDeg); + tempMultiplier = findMultiplier(polyOne[firstPolyDeg], polyTwo[secondPolyDeg]); + tempArr = shiftValuesInArray(tempArr, shift); + tempArr = multiplyPolyByNumber(tempArr, tempMultiplier); + tempArr = moduloArray(tempArr); + polyOne = subtractTwoPolynomials(polyOne, tempArr); + firstPolyDeg--; + shift++; } - return remainder; + result = Arrays.copyOf(polyOne, shift - 1); + return result; } - private List calcQuotient(List firstPoly, List secondPoly, int[] quotient) throws MultiplierNotFoundException, DivisionErrorException { - int firstPolyDegree = firstPoly.size() - 1; - int secondPolyDegree = secondPoly.size() - 1; - if (firstPolyDegree < secondPolyDegree) { - throw new DivisionErrorException(); + private void fillTemporaryArray(int[] polyTwo, int[] tempArr) { + for (int i = 0; i < polyTwo.length; i++) { + tempArr[tempArr.length - 1 - i] = polyTwo[polyTwo.length - 1 - i]; } - int quotientCoefficient; - if ((((float) firstPoly.get(firstPolyDegree) / (float) secondPoly.get(secondPolyDegree))) == Math.round(firstPoly.get(firstPolyDegree) / secondPoly.get(secondPolyDegree))) { - quotientCoefficient = firstPoly.get(firstPolyDegree) / secondPoly.get(secondPolyDegree); - } else { - quotientCoefficient = invElem(firstPoly.get(firstPolyDegree), secondPoly.get(secondPolyDegree)); - } - quotient[firstPolyDegree - secondPolyDegree] += quotientCoefficient; - List newPoly = generatePolyFromIndexAndValue(firstPolyDegree - secondPolyDegree, quotientCoefficient); - Integer[] multipliedPolynomials = multiplyPolynomials(newPoly, secondPoly); - List polynomialAfterFirstDivide = new ArrayList<>(Arrays.asList(multipliedPolynomials)); - - return removeUnnecessaryZeros(subtractTwoPolynomials(firstPoly, polynomialAfterFirstDivide)); } - private List removeUnnecessaryZeros(List polynomialAfterSubtract) { - int amountOfZeros = 0; - for (int i = polynomialAfterSubtract.size() - 1; i >= 0; i--) { - if (polynomialAfterSubtract.get(i) == 0) { - amountOfZeros++; - } else { - break; - } + private int[] subtractTwoPolynomials(int[] polyOne, int[] polyTwo) { + int[] result = new int[polyOne.length]; + for (int i = 0; i < polyOne.length; i++) { + result[i] = polyOne[i] - polyTwo[i]; } - - polynomialAfterSubtract = polynomialAfterSubtract.subList(0, polynomialAfterSubtract.size() - amountOfZeros); - return polynomialAfterSubtract; + return result; } - private List subtractTwoPolynomials(List firstPoly, List secondPoly) { - List subtractedPolynomial = new ArrayList<>(Collections.nCopies(firstPoly.size() + secondPoly.size(), 0)); - for (int index = firstPoly.size(); index >= 0; index--) { - if (index < secondPoly.size()) { - subtractedPolynomial.set(index, firstPoly.get(index) - secondPoly.get(index)); - parseNegativeElement(subtractedPolynomial, index); - } + private int[] moduloArray(int[] array) { + for (int i = 0; i < array.length; i++) { + array[i] = array[i] % n; } - return subtractedPolynomial; + return array; } - private void parseNegativeElement(List subtractedPolynomial, int index) { - while (subtractedPolynomial.get(index) < 0) - subtractedPolynomial.set(index, (subtractedPolynomial.get(index) * subtractedPolynomial.get(index)) % n); - } - - private List generatePolyFromIndexAndValue(int size, int quotientCoefficient) { - List poly = new ArrayList<>(Collections.nCopies(size + 1, 0)); - poly.set(size, quotientCoefficient); + private int[] multiplyPolyByNumber(int[] poly, int multiplier) { + for (int i = 0; i < poly.length; i++) { + poly[i] = poly[i] * multiplier; + } return poly; } - private int invElem(int a, int b) throws MultiplierNotFoundException { + private int[] shiftValuesInArray(int[] array, int amount) { + if (amount == 0) { + return array; + } else { + int[] res = new int[array.length]; + System.arraycopy(array, amount, res, 0, array.length - amount); + for (int j = array.length - amount + 1; j < res.length; j++) { + res[j] = 0; + } + return res; + } + } + private void parseNegativeElement(int[] polyOne, int firstPolyDeg) { + while (polyOne[firstPolyDeg] < 0) { + polyOne[firstPolyDeg] = n + polyOne[firstPolyDeg]; + } + } + + private int findMultiplier(int a, int b) { for (int i = 0; i < n; i++) { if (a == (b * i) % n) { return i; } } - - throw new MultiplierNotFoundException(); + return -1; } - public void printAllValuesToStandardOutput() throws DivisionErrorException, MultiplierNotFoundException { - List> values = new ArrayList<>(); - values.add(Arrays.asList(multiplyPolynomials(firstPolynomial, secondPolynomial))); - values.add(Arrays.stream(moduloDividePolynomialsReturnQuotient(firstPolynomial, secondPolynomial)).boxed().collect(Collectors.toList())); - try { - values.add(gcd(firstPolynomial, secondPolynomial)); - } catch (MultiplierNotFoundException e) { + public String printMultipliedPoly() { + return Arrays.toString(multiplyPolynomials(firstPolynomialAsArray, secondPolynomialAsArray)); + } + + public String printSubtractedPoly() { + int[] result = polyDiv(firstPolynomialAsArray, secondPolynomialAsArray); + if (result == null) { + return "Division Error"; + } else if (result.length == 0) { + return "[0]"; + } else { + return Arrays.toString(polyDiv(firstPolynomialAsArray, secondPolynomialAsArray)); } - System.out.println(values); } - private List gcd(List polyOne, List polyTwo) throws MultiplierNotFoundException, DivisionErrorException { - if (polyTwo.isEmpty()) return polyOne; - List poly = Arrays.stream(moduloDividePolynomialsReturnQuotient(polyOne, polyTwo)).boxed().collect(Collectors.toList()); - return gcd(polyTwo, poly); + public String printGcd() { + int[] gcd = gcd(firstPolynomialAsArray, secondPolynomialAsArray); + if (gcd == null) { + return "Division Error"; + } else + return Arrays.toString(gcd); + } + private int[] gcd(int[] firstPoly, int[] secondPoly) { + if (secondPoly.length == 0) { + return firstPoly; + } + if (firstPoly.length >= secondPoly.length) { + return gcd(secondPoly, polyDiv(firstPoly, secondPoly)); + } else { + return gcd(secondPoly, polyDiv(secondPoly, firstPoly)); + } } }