public void testEByTaylorSeries() { //System.out.println("--------------------------------"); //System.out.println("Computing e by Taylor series"); DD testE = computeEByTaylorSeries(); double err = Math.abs(testE.subtract(DD.E).doubleValue()); //System.out.println("Difference from DoubleDouble.E = " + err); assertTrue(err < 64 * DD.EPS); }
private void checkParse(String str, DD expectedVal, double relErrBound) { DD xdd = DD.parse(str); double err = xdd.subtract(expectedVal).doubleValue(); double xddd = xdd.doubleValue(); double relErr = xddd == 0d ? err : Math.abs(err / xddd); //System.out.println("Parsed= " + xdd + " rel err= " + relErr); assertTrue("parsing '" + str + "' results in " + xdd.toString() + " ( " + xdd.dump() + ") != " + expectedVal + "\n err =" + err + ", relerr =" + relErr, relErr <= relErrBound); }
while (xdd.doubleValue() > 1e-300) { count++; double x = xdd.doubleValue(); DD xSqrt = xdd.sqrt(); String s = xSqrt.toString(); double err = Math.abs(xx.doubleValue() - x); double distFrom1 = distFrom1DD.doubleValue(); if (Math.abs(distFrom1) < 1.0e-40) break;
public void testPiByMachin() { //System.out.println("--------------------------------"); //System.out.println("Computing Pi by Machin's rule"); DD testE = computePiByMachin(); double err = Math.abs(testE.subtract(DD.PI).doubleValue()); //System.out.println("Difference from DoubleDouble.PI = " + err); assertTrue(err < 8 * DD.EPS); }
public void testSetValueDouble() { assertTrue(VALUE_DBL == (new DD(1)).setValue(VALUE_DBL).doubleValue()); } public void testSetValueDD()
private void checkErrorBound(String tag, DD x, DD y, double errBound) { DD err = x.subtract(y).abs(); //System.out.println(tag + " err=" + err); boolean isWithinEps = err.doubleValue() <= errBound; assertTrue(isWithinEps); }
/** * This routine simply tests for robustness of the toString function. * * @param xdd the value to test (write and parse) */ private void writeRepeatedSqr(DD xdd) { if (xdd.ge(DD.valueOf(1))) throw new IllegalArgumentException("Argument must be < 1"); int count = 0; while (xdd.doubleValue() > 1e-300) { count++; if (count == 100) count = count; double x = xdd.doubleValue(); DD xSqr = xdd.sqr(); String s = xSqr.toString(); //System.out.println(count + ": " + s); DD xSqr2 = DD.parse(s); xdd = xSqr; } }
private void checkPow(double x, int exp, double errBound) { DD xdd = new DD(x); DD pow = xdd.pow(exp); //System.out.println("Pow(" + x + ", " + exp + ") = " + pow); DD pow2 = slowPow(xdd, exp); double err = pow.subtract(pow2).doubleValue(); boolean isOK = err < errBound; if (! isOK) System.out.println("Test slowPow value " + pow2); assertTrue(err <= errBound); }
private void checkReciprocal(double x, double errBound) { DD xdd = new DD(x); DD rr = xdd.reciprocal().reciprocal(); double err = xdd.subtract(rr).doubleValue(); //System.out.println("DD Recip = " + xdd // + " DD delta= " + err // + " double recip delta= " + (x - 1.0/(1.0/x)) ); assertTrue(err <= errBound); }
/** * Uses Taylor series to compute e * * e = 1 + 1 + 1/2! + 1/3! + 1/4! + ... * * @return an approximation to e */ private DD computeEByTaylorSeries() { DD s = DD.valueOf(2.0); DD t = DD.valueOf(1.0); double n = 1.0; int i = 0; while (t.doubleValue() > DD.EPS) { i++; n += 1.0; t = t.divide(DD.valueOf(n)); s = s.add(t); //System.out.println(i + ": " + s); } return s; }
/** * Tests that printing values with many decimal places works. * This tests the correctness and robustness of both output and input. * * @param x the value to test */ private void writeAndReadSqrt(double x) { DD xdd = DD.valueOf(x); DD xSqrt = xdd.sqrt(); String s = xSqrt.toString(); // System.out.println(s); DD xSqrt2 = DD.parse(s); DD xx = xSqrt2.multiply(xSqrt2); String xxStr = xx.toString(); // System.out.println("==> " + xxStr); DD xx2 = DD.parse(xxStr); double err = Math.abs(xx2.doubleValue() - x); assertTrue(err < 1e-10); }
.selfMultiply(DD.valueOf(p1.x).selfSubtract(q1.x)); DD numx = numx1.subtract(numx2); double fracP = numx.selfDivide(denom).doubleValue(); double x = DD.valueOf(p1.x).selfAdd(DD.valueOf(p2.x).selfSubtract(p1.x).selfMultiply(fracP)).doubleValue(); .selfMultiply(DD.valueOf(p1.x).selfSubtract(q1.x)); DD numy = numy1.subtract(numy2); double fracQ = numy.selfDivide(denom).doubleValue(); double y = DD.valueOf(q1.y).selfAdd(DD.valueOf(q2.y).selfSubtract(q1.y).selfMultiply(fracQ)).doubleValue();
public static boolean isInCircleDDFast( Coordinate a, Coordinate b, Coordinate c, Coordinate p) { DD aTerm = (DD.sqr(a.x).selfAdd(DD.sqr(a.y))) .selfMultiply(triAreaDDFast(b, c, p)); DD bTerm = (DD.sqr(b.x).selfAdd(DD.sqr(b.y))) .selfMultiply(triAreaDDFast(a, c, p)); DD cTerm = (DD.sqr(c.x).selfAdd(DD.sqr(c.y))) .selfMultiply(triAreaDDFast(a, b, p)); DD pTerm = (DD.sqr(p.x).selfAdd(DD.sqr(p.y))) .selfMultiply(triAreaDDFast(a, b, c)); DD sum = aTerm.selfSubtract(bTerm).selfAdd(cTerm).selfSubtract(pTerm); boolean isInCircle = sum.doubleValue() > 0; return isInCircle; }
DD d = new DD(1.0); int sign = 1; while (t.doubleValue() > DD.EPS) { k++; if (sign < 0)
public static boolean isInCircleDDNormalized( Coordinate a, Coordinate b, Coordinate c, Coordinate p) { DD adx = DD.valueOf(a.x).selfSubtract(p.x); DD ady = DD.valueOf(a.y).selfSubtract(p.y); DD bdx = DD.valueOf(b.x).selfSubtract(p.x); DD bdy = DD.valueOf(b.y).selfSubtract(p.y); DD cdx = DD.valueOf(c.x).selfSubtract(p.x); DD cdy = DD.valueOf(c.y).selfSubtract(p.y); DD abdet = adx.multiply(bdy).selfSubtract(bdx.multiply(ady)); DD bcdet = bdx.multiply(cdy).selfSubtract(cdx.multiply(bdy)); DD cadet = cdx.multiply(ady).selfSubtract(adx.multiply(cdy)); DD alift = adx.multiply(adx).selfAdd(ady.multiply(ady)); DD blift = bdx.multiply(bdx).selfAdd(bdy.multiply(bdy)); DD clift = cdx.multiply(cdx).selfAdd(cdy.multiply(cdy)); DD sum = alift.selfMultiply(bcdet) .selfAdd(blift.selfMultiply(cadet)) .selfAdd(clift.selfMultiply(abdet)); boolean isInCircle = sum.doubleValue() > 0; return isInCircle; }
boolean isInCircle = sum.doubleValue() > 0;
public static boolean isInCircleDD2( Coordinate a, Coordinate b, Coordinate c, Coordinate p) { DD aTerm = (DD.sqr(a.x).selfAdd(DD.sqr(a.y))) .selfMultiply(triAreaDD2(b, c, p)); DD bTerm = (DD.sqr(b.x).selfAdd(DD.sqr(b.y))) .selfMultiply(triAreaDD2(a, c, p)); DD cTerm = (DD.sqr(c.x).selfAdd(DD.sqr(c.y))) .selfMultiply(triAreaDD2(a, b, p)); DD pTerm = (DD.sqr(p.x).selfAdd(DD.sqr(p.y))) .selfMultiply(triAreaDD2(a, b, c)); DD sum = aTerm.selfSubtract(bTerm).selfAdd(cTerm).selfSubtract(pTerm); boolean isInCircle = sum.doubleValue() > 0; return isInCircle; } public static boolean isInCircleDD3(
public static boolean isInCircleDD3( Coordinate a, Coordinate b, Coordinate c, Coordinate p) { DD adx = DD.valueOf(a.x).selfSubtract(p.x); DD ady = DD.valueOf(a.y).selfSubtract(p.y); DD bdx = DD.valueOf(b.x).selfSubtract(p.x); DD bdy = DD.valueOf(b.y).selfSubtract(p.y); DD cdx = DD.valueOf(c.x).selfSubtract(p.x); DD cdy = DD.valueOf(c.y).selfSubtract(p.y); DD abdet = adx.multiply(bdy).selfSubtract(bdx.multiply(ady)); DD bcdet = bdx.multiply(cdy).selfSubtract(cdx.multiply(bdy)); DD cadet = cdx.multiply(ady).selfSubtract(adx.multiply(cdy)); DD alift = adx.multiply(adx).selfSubtract(ady.multiply(ady)); DD blift = bdx.multiply(bdx).selfSubtract(bdy.multiply(bdy)); DD clift = cdx.multiply(cdx).selfSubtract(cdy.multiply(cdy)); DD sum = alift.selfMultiply(bcdet) .selfAdd(blift.selfMultiply(cadet)) .selfAdd(clift.selfMultiply(abdet)); boolean isInCircle = sum.doubleValue() > 0; return isInCircle; }
boolean isInCircle = sum.doubleValue() > 0;