/** * Squares this object. * To prevent altering constants, * this method <b>must only</b> be used on values known to * be newly created. * * @return the square of this value. */ public DD selfSqr() { return this.selfMultiply(this); }
/** * Multiplies this object by the argument, returning <tt>this</tt>. * To prevent altering constants, * this method <b>must only</b> be used on values known to * be newly created. * * @param y the value to multiply by * @return this object, multiplied by y */ public final DD selfMultiply(DD y) { return selfMultiply(y.hi, y.lo); }
/** * Multiplies this object by the argument, returning <tt>this</tt>. * To prevent altering constants, * this method <b>must only</b> be used on values known to * be newly created. * * @param y the value to multiply by * @return this object, multiplied by y */ public final DD selfMultiply(double y) { return selfMultiply(y, 0.0); }
/** * Computes the square of this value. * * @return the square of this value. */ public static DD sqr(double x) { return valueOf(x).selfMultiply(x); }
/** * Returns a new DoubleDouble whose value is <tt>(this * y)</tt>. * * @param y the multiplicand * @return <tt>(this * y)</tt> */ public final DD multiply(double y) { if (Double.isNaN(y)) return createNaN(); return copy(this).selfMultiply(y, 0.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); }
public static DD triAreaDDFast( Coordinate a, Coordinate b, Coordinate c) { DD t1 = DD.valueOf(b.x).selfSubtract(a.x) .selfMultiply( DD.valueOf(c.y).selfSubtract(a.y)); DD t2 = DD.valueOf(b.y).selfSubtract(a.y) .selfMultiply( DD.valueOf(c.x).selfSubtract(a.x)); return t1.selfSubtract(t2); }
if (Character.isDigit(ch)) { double d = ch - '0'; val.selfMultiply(TEN);
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; }
/** * Returns the index of the direction of the point <code>q</code> relative to * a vector specified by <code>p1-p2</code>. * * @param p1 the origin point of the vector * @param p2 the final point of the vector * @param q the point to compute the direction to * * @return 1 if q is counter-clockwise (left) from p1-p2 * @return -1 if q is clockwise (right) from p1-p2 * @return 0 if q is collinear with p1-p2 */ public static int orientationIndex(Coordinate p1, Coordinate p2, Coordinate q) { // fast filter for orientation index // avoids use of slow extended-precision arithmetic in many cases int index = orientationIndexFilter(p1, p2, q); if (index <= 1) return index; // normalize coordinates DD dx1 = DD.valueOf(p2.x).selfAdd(-p1.x); DD dy1 = DD.valueOf(p2.y).selfAdd(-p1.y); DD dx2 = DD.valueOf(q.x).selfAdd(-p2.x); DD dy2 = DD.valueOf(q.y).selfAdd(-p2.y); // sign of determinant - unrolled for performance return dx1.selfMultiply(dy2).selfSubtract(dy1.selfMultiply(dx2)).signum(); }
.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); .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(); .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 double runDoubleDoubleSelf(int nIter) { Stopwatch sw = new Stopwatch(); for (int i = 0; i < nIter; i++) { double a = 9.0; double factor = 10.0; DD c = new DD(9.0); c.selfMultiply(factor); DD b = new DD(9.0); b.selfDivide(factor); DD a2 = new DD(a); a2.selfMultiply(a); DD b2 = new DD(b); b2.selfMultiply(c); a2.selfDivide(b2); DD det = a2; // System.out.println(aDiv); // System.out.println(det); } sw.stop(); System.out.println("DD-Self: nIter = " + nIter + " time = " + sw.getTimeString()); return sw.getTime() / (double) nIter; } //*/
public static DD triAreaDD2( Coordinate a, Coordinate b, Coordinate c) { DD t1 = DD.valueOf(b.x).selfSubtract(a.x) .selfMultiply( DD.valueOf(c.y).selfSubtract(a.y)); DD t2 = DD.valueOf(b.y).selfSubtract(a.y) .selfMultiply( DD.valueOf(c.x).selfSubtract(a.x)); return t1.selfSubtract(t2); }
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 DD orientationDet(Coordinate p1, Coordinate p2, Coordinate q, DDConverter conv) { // normalize coordinates DD dx1 = conv.convert(p2.x).selfAdd(conv.convert(-p1.x)); DD dy1 = conv.convert(p2.y).selfAdd(conv.convert(-p1.y)); DD dx2 = conv.convert(q.x).selfAdd(conv.convert(-p2.x)); DD dy2 = conv.convert(q.y).selfAdd(conv.convert(-p2.y)); // sign of determinant - unrolled for performance return dx1.selfMultiply(dy2).selfSubtract(dy1.selfMultiply(dx2)); }
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 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; }