From e3912397d77159692520fe771463dfd87988e008 Mon Sep 17 00:00:00 2001 From: XDrake99 Date: Mon, 5 Dec 2016 22:57:11 +0100 Subject: [PATCH] Added timeout and Multiplication Method 1 --- Algebra Cheat Sheet.rtf | Bin 5307 -> 5401 bytes README.md | 5 +- res/decimal.png | Bin 0 -> 7582 bytes res/font_ex.rft | Bin 1633 -> 1667 bytes src/org/warp/picalculator/Errors.java | 2 +- .../warp/picalculator/math/Calculator.java | 5 ++ .../math/functions/Multiplication.java | 4 + .../picalculator/math/functions/Number.java | 46 ++++++++++ .../math/functions/Subtraction.java | 4 + .../rules/methods/MultiplicationMethod1.java | 84 ++++++++++++++++++ 10 files changed, 147 insertions(+), 3 deletions(-) create mode 100644 res/decimal.png create mode 100644 src/org/warp/picalculator/math/rules/methods/MultiplicationMethod1.java diff --git a/Algebra Cheat Sheet.rtf b/Algebra Cheat Sheet.rtf index 9897a8379355fa5385c2cfcd3d4d54356c7afdb0..51627ed15690bdbea9727a27bd58adbcbb657817 100644 GIT binary patch delta 66 zcmdn3Ia6x`m#{=qOqxMVTCs_Nf^TU~NoGM#W^!UlW`5q}8$xot5n9Gt5n4tHwhCri W5tA8tBsX&kuVrN8<*Mc7VgLZlz7oFx delta 18 ZcmbQKwOexom+U+zkN$#5#W; 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 dt = itm.solveOneStep(); + long t2 = System.currentTimeMillis(); + if (t2-t1 >= 3000) { + throw new Error(Errors.TIMEOUT); + } partialResults.addAll(dt); } else { partialResults.add(itm); diff --git a/src/org/warp/picalculator/math/functions/Multiplication.java b/src/org/warp/picalculator/math/functions/Multiplication.java index 2f991afe..91b6067e 100644 --- a/src/org/warp/picalculator/math/functions/Multiplication.java +++ b/src/org/warp/picalculator/math/functions/Multiplication.java @@ -9,6 +9,7 @@ import org.warp.picalculator.math.rules.NumberRule1; import org.warp.picalculator.math.rules.NumberRule2; import org.warp.picalculator.math.rules.NumberRule6; import org.warp.picalculator.math.rules.SyntaxRule1; +import org.warp.picalculator.math.rules.methods.MultiplicationMethod1; public class Multiplication extends FunctionTwoValues { @@ -40,6 +41,7 @@ public class Multiplication extends FunctionTwoValues { if (NumberRule2.compare(this)) return true; if (NumberRule6.compare(this)) return true; if (ExponentRule15.compare(this)) return true; + if (MultiplicationMethod1.compare(this)) return true; return false; } @@ -56,6 +58,8 @@ public class Multiplication extends FunctionTwoValues { result = NumberRule6.execute(this); } else if (ExponentRule15.compare(this)) { result = ExponentRule15.execute(this); + } else if (MultiplicationMethod1.compare(this)) { + result = MultiplicationMethod1.execute(this); } else if (variable1.isSolved() & variable2.isSolved()) { result.add(((Number)variable1).multiply((Number)variable2)); } diff --git a/src/org/warp/picalculator/math/functions/Number.java b/src/org/warp/picalculator/math/functions/Number.java index 999c55f2..d4a1f565 100644 --- a/src/org/warp/picalculator/math/functions/Number.java +++ b/src/org/warp/picalculator/math/functions/Number.java @@ -6,6 +6,7 @@ import static org.warp.picalculator.device.graphicengine.Display.Render.glGetStr import java.math.BigDecimal; import java.math.BigInteger; import java.util.ArrayList; +import java.util.LinkedList; import java.util.List; import org.nevec.rjm.BigDecimalMath; @@ -289,4 +290,49 @@ public class Number implements Function { * return 6*toString().length()-1; * } */ + + public boolean canBeFactorized() { + if (Utils.isIntegerValue(getTerm())) { + return getTerm().toBigIntegerExact().compareTo(BigInteger.valueOf(1)) > 1; + } + return false; + } + + public LinkedList getFactors() + { + BigInteger n = getTerm().toBigIntegerExact(); + BigInteger two = BigInteger.valueOf(2); + LinkedList fs = new LinkedList(); + + if (n.compareTo(two) < 0) + { + throw new IllegalArgumentException("must be greater than one"); + } + + while (n.mod(two).equals(BigInteger.ZERO)) + { + fs.add(two); + n = n.divide(two); + } + + if (n.compareTo(BigInteger.ONE) > 0) + { + BigInteger f = BigInteger.valueOf(3); + while (f.multiply(f).compareTo(n) <= 0) + { + if (n.mod(f).equals(BigInteger.ZERO)) + { + fs.add(f); + n = n.divide(f); + } + else + { + f = f.add(two); + } + } + fs.add(n); + } + + return fs; + } } diff --git a/src/org/warp/picalculator/math/functions/Subtraction.java b/src/org/warp/picalculator/math/functions/Subtraction.java index 63857b95..5525a2d0 100644 --- a/src/org/warp/picalculator/math/functions/Subtraction.java +++ b/src/org/warp/picalculator/math/functions/Subtraction.java @@ -11,6 +11,7 @@ import org.warp.picalculator.math.rules.NumberRule5; import org.warp.picalculator.math.rules.VariableRule1; import org.warp.picalculator.math.rules.VariableRule2; import org.warp.picalculator.math.rules.VariableRule3; +import org.warp.picalculator.math.rules.methods.SumMethod1; public class Subtraction extends FunctionTwoValues { @@ -40,6 +41,7 @@ public class Subtraction extends FunctionTwoValues { if (ExpandRule1.compare(this)) return true; if (ExpandRule5.compare(this)) return true; if (NumberRule5.compare(this)) return true; + if (SumMethod1.compare(this)) return true; return false; } @@ -60,6 +62,8 @@ public class Subtraction extends FunctionTwoValues { result = ExpandRule5.execute(this); } else if (NumberRule5.compare(this)) { result = NumberRule5.execute(this); + } else if (SumMethod1.compare(this)) { + result = SumMethod1.execute(this); } else if (variable1.isSolved() & variable2.isSolved()) { result.add(((Number)variable1).add(((Number)variable2).multiply(new Number(this.parent, "-1")))); } diff --git a/src/org/warp/picalculator/math/rules/methods/MultiplicationMethod1.java b/src/org/warp/picalculator/math/rules/methods/MultiplicationMethod1.java new file mode 100644 index 00000000..842913a6 --- /dev/null +++ b/src/org/warp/picalculator/math/rules/methods/MultiplicationMethod1.java @@ -0,0 +1,84 @@ +package org.warp.picalculator.math.rules.methods; + +import java.util.ArrayList; + +import org.warp.picalculator.Error; +import org.warp.picalculator.math.functions.Function; +import org.warp.picalculator.math.functions.Multiplication; +import org.warp.picalculator.math.functions.Number; + +/** + * Multiplication method
+ * Example: X*3*X*2 = 6*X^2 + * @author Andrea Cavalli + * + */ +public class MultiplicationMethod1 { + + public static boolean compare(Function f) { + return ((Multiplication)f).getVariable1().isSolved() && ((Multiplication)f).getVariable2().isSolved() && !(((Multiplication)f).getVariable1() instanceof Number && ((Multiplication)f).getVariable2() instanceof Number) && getFirstWorkingMultiplicationCouple(getMultiplicationElements(f)) != null; + } + + public static ArrayList execute(Function f) throws Error { + Function result; + ArrayList elements = getMultiplicationElements(f); + int[] workingElementCouple = getFirstWorkingMultiplicationCouple(elements); + Function elem1 = elements.get(workingElementCouple[0]); + Function elem2 = elements.get(workingElementCouple[1]); + + final int size = elements.size(); + Function prec = new Multiplication(null, elem1, elem2); + elem1.setParent(prec); + elem2.setParent(prec); + for (int i = size-1; i >= 0; i--) { + if (i != workingElementCouple[0] & i != workingElementCouple[1]) { + Function a = prec; + Function b = elements.get(i); + prec = new Multiplication(null, a, b); + a.setParent(prec); + b.setParent(prec); + } + } + prec.setParent(f.getParent()); + + result = prec; + + ArrayList results = new ArrayList<>(); + results.add(result); + return results; + } + + private static ArrayList getMultiplicationElements(Function mult) { + ArrayList elements = new ArrayList<>(); + while (mult instanceof Multiplication) { + elements.add(((Multiplication) mult).getVariable1()); + mult = ((Multiplication) mult).getVariable2(); + } + elements.add(mult); + return elements; + } + + private static int[] getFirstWorkingMultiplicationCouple(ArrayList elements) { + final int size = elements.size(); + Function a; + Function b; + if (elements.size() == 2) { + return null; + } + for (int i = 0; i < size; i++) { + a = elements.get(i); + for (int j = 0; j < size; j++) { + b = elements.get(j); + if (i != j) { + Function testFunc; + testFunc = new Multiplication(null, a, b); + if (!testFunc.isSolved()) { + return new int[]{i, j}; + } + } + } + } + return null; + } + +}