/** * Adds the argument to the value of <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 addend * @return this object, increased by y */ public final DD selfAdd(DD y) { return selfAdd(y.hi, y.lo); }
/** * Returns a new DoubleDouble whose value is <tt>(this + y)</tt>. * * @param y the addend * @return <tt>(this + y)</tt> */ public final DD add(double y) { return copy(this).selfAdd(y); }
/** * Returns a new DoubleDouble whose value is <tt>(this + y)</tt>. * * @param y the addend * @return <tt>(this + y)</tt> */ public final DD add(DD y) { return copy(this).selfAdd(y); }
/** * Subtracts the argument from the value of <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 addend * @return this object, decreased by y */ public final DD selfSubtract(double y) { if (isNaN()) return this; return selfAdd(-y, 0.0); }
/** * Subtracts the argument from the value of <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 addend * @return this object, decreased by y */ public final DD selfSubtract(DD y) { if (isNaN()) return this; return selfAdd(-y.hi, -y.lo); }
/** * 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(); }
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; }
val.selfMultiply(TEN); val.selfAdd(d); numDigits++; continue;
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; }
.multiply(TEN)); if (rebiasBy10) y.selfAdd(TEN);
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(
double fracP = numx.selfDivide(denom).doubleValue(); double x = DD.valueOf(p1.x).selfAdd(DD.valueOf(p2.x).selfSubtract(p1.x).selfMultiply(fracP)).doubleValue(); 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 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; }