return valueOf(1.0); DD r = new DD(this); DD s = valueOf(1.0); int n = Math.abs(exp); s.selfMultiply(r); r = r.sqr(); return s.reciprocal(); return s;
Coordinate a, Coordinate b, Coordinate c, Coordinate p) { DD px = DD.valueOf(p.x); DD py = DD.valueOf(p.y); DD ax = DD.valueOf(a.x); DD ay = DD.valueOf(a.y); DD bx = DD.valueOf(b.x); DD by = DD.valueOf(b.y); DD cx = DD.valueOf(c.x); DD cy = DD.valueOf(c.y); DD aTerm = (ax.multiply(ax).add(ay.multiply(ay))) .multiply(triAreaDDSlow(bx, by, cx, cy, px, py)); DD bTerm = (bx.multiply(bx).add(by.multiply(by))) .multiply(triAreaDDSlow(ax, ay, cx, cy, px, py)); DD cTerm = (cx.multiply(cx).add(cy.multiply(cy))) .multiply(triAreaDDSlow(ax, ay, bx, by, px, py)); DD pTerm = (px.multiply(px).add(py.multiply(py))) .multiply(triAreaDDSlow(ax, ay, bx, by, cx, cy)); DD sum = aTerm.subtract(bTerm).add(cTerm).subtract(pTerm); boolean isInCircle = sum.doubleValue() > 0;
/** * Returns a new DoubleDouble whose value is <tt>(this * y)</tt>. * * @param y the multiplicand * @return <tt>(this * y)</tt> */ public final DD multiply(DD y) { if (y.isNaN()) return createNaN(); return copy(this).selfMultiply(y); }
DD y = this.abs(); int mag = magnitude(y.hi); DD scale = TEN.pow(mag); y = y.divide(scale); if (y.gt(TEN)) { y = y.divide(TEN); mag += 1; else if (y.lt(ONE)) { y = y.multiply(TEN); mag -= 1; y = (y.subtract(DD.valueOf(digit)) .multiply(TEN)); if (rebiasBy10) y.selfAdd(TEN); int remMag = magnitude(y.hi); if (remMag < 0 && Math.abs(remMag) >= (numDigits - i)) continueExtractingDigits = false;
/** * 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); }
void checkBinomial2(double a, double b) DD add = new DD(a); DD bdd = new DD(b); DD aPlusb = add.add(bdd); DD aSubb = add.subtract(bdd); DD abProd = aPlusb.multiply(aSubb); DD a2dd = add.multiply(add); DD b2dd = bdd.multiply(bdd); DD diff = abProd.subtract(a2dd).negate(); DD delta = diff.subtract(b2dd); boolean isSame = diff.equals(b2dd); assertTrue(isSame); boolean isDeltaZero = delta.isZero(); assertTrue(isDeltaZero);
Coordinate q1, Coordinate q2) DD denom1 = DD.valueOf(q2.y).selfSubtract(q1.y) .selfMultiply(DD.valueOf(p2.x).selfSubtract(p1.x)); DD denom2 = DD.valueOf(q2.x).selfSubtract(q1.x) .selfMultiply(DD.valueOf(p2.y).selfSubtract(p1.y)); DD denom = denom1.subtract(denom2); DD numx1 = DD.valueOf(q2.x).selfSubtract(q1.x) .selfMultiply(DD.valueOf(p1.y).selfSubtract(q1.y)); DD numx2 = DD.valueOf(q2.y).selfSubtract(q1.y) .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(); DD numy1 = DD.valueOf(p2.x).selfSubtract(p1.x) .selfMultiply(DD.valueOf(p1.y).selfSubtract(q1.y)); DD numy2 = DD.valueOf(p2.y).selfSubtract(p1.y) .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 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; }
public static final DD PI = new DD( 3.141592653589793116e+00, 1.224646799147353207e-16); public static final DD TWO_PI = new DD( 6.283185307179586232e+00, 2.449293598294706414e-16); public static final DD PI_2 = new DD( 1.570796326794896558e+00, 6.123233995736766036e-17); public static final DD E = new DD( 2.718281828459045091e+00, 1.445646891729250158e-16); public static final DD NaN = new DD(Double.NaN, Double.NaN); if (isZero()) return valueOf(0.0); if (isNegative()) { return NaN; DD axdd = valueOf(ax); DD diffSq = this.subtract(axdd.sqr()); double d2 = diffSq.hi * (x * 0.5); return axdd.add(d2);
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; }
/** * 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; } }
Coordinate a, Coordinate b, Coordinate c, Coordinate p) { DD px = new DD(p.x); DD py = new DD(p.y); DD ax = new DD(a.x); DD ay = new DD(a.y); DD bx = new DD(b.x); DD by = new DD(b.y); DD cx = new DD(c.x); DD cy = new DD(c.y); DD aTerm = (ax.multiply(ax).add(ay.multiply(ay))) .multiply(triAreaDD(bx, by, cx, cy, px, py)); DD bTerm = (bx.multiply(bx).add(by.multiply(by))) .multiply(triAreaDD(ax, ay, cx, cy, px, py)); DD cTerm = (cx.multiply(cx).add(cy.multiply(cy))) .multiply(triAreaDD(ax, ay, bx, by, px, py)); DD pTerm = (px.multiply(px).add(py.multiply(py))) .multiply(triAreaDD(ax, ay, bx, by, cx, cy)); DD sum = aTerm.subtract(bTerm).add(cTerm).subtract(pTerm); boolean isInCircle = sum.doubleValue() > 0;
public double xrunDoubleDoubleSelf(int nIter) { Stopwatch sw = new Stopwatch(); for (int i = 0; i < nIter; i++) { DD a = new DD(9.0); DD factor = new DD(10.0); DD aMul = factor.multiply(a); DD aDiv = a.divide(factor); DD det = a.multiply(a) .subtract(aMul.multiply(aDiv)); // System.out.println(aDiv); // System.out.println(det); } sw.stop(); System.out.println("DD: nIter = " + nIter + " time = " + sw.getTimeString()); return sw.getTime() / (double) nIter; }
/** * Returns the absolute value of this value. * Special cases: * <ul> * <li>If this value is NaN, it is returned. * </ul> * * @return the absolute value of this value */ public DD abs() { if (isNaN()) return NaN; if (isNegative()) return negate(); return new DD(this); }
/** * Computes the sign of the determinant of the 2x2 matrix * with the given entries. * * @return -1 if the determinant is negative, * @return 1 if the determinant is positive, * @return 0 if the determinant is 0. */ public static int signOfDet2x2(double dx1, double dy1, double dx2, double dy2) { DD x1 = DD.valueOf(dx1); DD y1 = DD.valueOf(dy1); DD x2 = DD.valueOf(dx2); DD y2 = DD.valueOf(dy2); DD det = x1.multiply(y2).selfSubtract(y1.multiply(x2)); return det.signum(); }
private DD slowPow(DD x, int exp) { if (exp == 0) return DD.valueOf(1.0); int n = Math.abs(exp); // MD - could use binary exponentiation for better precision & speed DD pow = new DD(x); for (int i = 1; i < n; i++) { pow = pow.multiply(x); } if (exp < 0) { return pow.reciprocal(); } return pow; }