Ejemplo n.º 1
0
  public void addScale(double s) {
    if (MathUtils.equals(s, 0., EPSILON)) throw new ArithmeticException("Scale is too small");
    if (MathUtils.equals(1. / s, 0, EPSILON)) throw new ArithmeticException("Scale is too big");

    Array2DRowRealMatrix scaleMatrix = new Array2DRowRealMatrix(IDENTITY_MATRIX.getDataRef());
    scaleMatrix.setEntry(0, 0, s);
    scaleMatrix.setEntry(1, 1, s);

    addTransformation(scaleMatrix);
  }
 /**
  * Returns true iff <code>object</code> is an <code>AbstractStorelessUnivariateStatistic</code>
  * returning the same values as this for <code>getResult()</code> and <code>getN()</code>
  *
  * @param object object to test equality against.
  * @return true if object returns the same value as this
  */
 @Override
 public boolean equals(Object object) {
   if (object == this) {
     return true;
   }
   if (object instanceof AbstractStorelessUnivariateStatistic == false) {
     return false;
   }
   AbstractStorelessUnivariateStatistic stat = (AbstractStorelessUnivariateStatistic) object;
   return (MathUtils.equals(stat.getResult(), this.getResult())
       && MathUtils.equals(stat.getN(), this.getN()));
 }
Ejemplo n.º 3
0
  public void addRotate(double rad) {
    if (MathUtils.equals(rad, 0, EPSILON)) return;

    Array2DRowRealMatrix rotateMatrix = new Array2DRowRealMatrix(IDENTITY_MATRIX.getDataRef());
    double sin = Math.sin(rad);
    double cos = Math.cos(rad);
    rotateMatrix.setEntry(0, 0, cos);
    rotateMatrix.setEntry(0, 1, -sin);
    rotateMatrix.setEntry(1, 0, sin);
    rotateMatrix.setEntry(1, 1, cos);

    addTransformation(rotateMatrix);
  }
Ejemplo n.º 4
0
  /**
   * Solves Phase 1 of the Simplex method.
   *
   * @param tableau simple tableau for the problem
   * @exception OptimizationException if the maximal number of iterations is exceeded, or if the
   *     problem is found not to have a bounded solution, or if there is no feasible solution
   */
  protected void solvePhase1(final SimplexTableau tableau) throws OptimizationException {
    // make sure we're in Phase 1
    if (tableau.getNumArtificialVariables() == 0) {
      return;
    }

    while (!isPhase1Solved(tableau)) {
      doIteration(tableau);
    }

    // if W is not zero then we have no feasible solution
    if (!MathUtils.equals(tableau.getEntry(0, tableau.getRhsOffset()), 0, epsilon)) {
      throw new NoFeasibleSolutionException();
    }
  }
  public void test13() throws Throwable {

    java.lang.Double var0 = new java.lang.Double((-1.0d));
    double[] var1 = new double[] {var0};
    org.apache.commons.math.linear.OpenMapRealVector var2 =
        new org.apache.commons.math.linear.OpenMapRealVector(var1);
    java.lang.Double var3 = new java.lang.Double((-1.0d));
    double[] var4 = new double[] {var3};
    org.apache.commons.math.linear.OpenMapRealVector var5 =
        new org.apache.commons.math.linear.OpenMapRealVector(var4);
    org.apache.commons.math.linear.OpenMapRealVector var6 = var2.add(var5);
    org.apache.commons.math.linear.OpenMapRealVector var7 =
        new org.apache.commons.math.linear.OpenMapRealVector(var6);
    java.lang.Double var8 = new java.lang.Double((-1.0d));
    java.lang.Double var9 = new java.lang.Double(0.0d);
    java.lang.Double var10 = new java.lang.Double((-1.0d));
    double[] var11 = new double[] {var8, var9, var10};
    org.apache.commons.math.linear.ArrayRealVector var12 =
        new org.apache.commons.math.linear.ArrayRealVector(var11);
    java.lang.Double var13 = new java.lang.Double((-1.0d));
    java.lang.Double var14 = new java.lang.Double(0.0d);
    java.lang.Double var15 = new java.lang.Double((-1.0d));
    double[] var16 = new double[] {var13, var14, var15};
    org.apache.commons.math.linear.ArrayRealVector var17 =
        new org.apache.commons.math.linear.ArrayRealVector(var16);
    org.apache.commons.math.linear.RealVector var18 =
        var12.ebeDivide((org.apache.commons.math.linear.RealVector) var17);
    java.lang.Double var19 = new java.lang.Double(0.0d);
    java.lang.Double var20 = new java.lang.Double((-1.0d));
    java.lang.Double var21 = new java.lang.Double((-1.0d));
    int var22 =
        org.apache.commons.math.util.MathUtils.compareTo(
            (double) var19, (double) var20, (double) var21);
    org.apache.commons.math.linear.RealVector var23 = var12.mapDivide((double) var20);
    org.apache.commons.math.linear.RealVector var24 = var7.mapSubtractToSelf((double) var20);
    double var25 = var7.getSparcity();
    java.lang.Double var26 = new java.lang.Double((-1.0d));
    double[] var27 = new double[] {var26};
    org.apache.commons.math.linear.OpenMapRealVector var28 =
        new org.apache.commons.math.linear.OpenMapRealVector(var27);
    int var29 = var28.getDimension();
    java.lang.Double var30 = new java.lang.Double((-1.0d));
    java.lang.Double var31 = new java.lang.Double(0.0d);
    java.lang.Double var32 = new java.lang.Double((-1.0d));
    double[] var33 = new double[] {var30, var31, var32};
    org.apache.commons.math.linear.ArrayRealVector var34 =
        new org.apache.commons.math.linear.ArrayRealVector(var33);
    java.lang.Double var35 = new java.lang.Double((-1.0d));
    java.lang.Double var36 = new java.lang.Double(0.0d);
    java.lang.Double var37 = new java.lang.Double((-1.0d));
    double[] var38 = new double[] {var35, var36, var37};
    org.apache.commons.math.linear.ArrayRealVector var39 =
        new org.apache.commons.math.linear.ArrayRealVector(var38);
    org.apache.commons.math.linear.RealVector var40 =
        var34.ebeDivide((org.apache.commons.math.linear.RealVector) var39);
    java.lang.Double var41 = new java.lang.Double((-1.0d));
    java.lang.Double var42 = new java.lang.Double(10.0d);
    java.lang.Double var43 = new java.lang.Double(100.0d);
    int var44 =
        org.apache.commons.math.util.MathUtils.compareTo(
            (double) var41, (double) var42, (double) var43);
    org.apache.commons.math.linear.RealVector var45 = var39.mapPowToSelf((double) var43);
    org.apache.commons.math.linear.ArrayRealVector var46 =
        new org.apache.commons.math.linear.ArrayRealVector(var29, var43);
    java.lang.Double var47 = new java.lang.Double((-1.0d));
    java.lang.Double var48 = new java.lang.Double(10.0d);
    java.lang.Double var49 = new java.lang.Double(1.0d);
    java.lang.Double var50 = new java.lang.Double(1.0d);
    boolean var51 = org.apache.commons.math.util.MathUtils.equals((double) var49, (double) var50);
    int var52 =
        org.apache.commons.math.util.MathUtils.compareTo(
            (double) var47, (double) var48, (double) var49);
    java.lang.Double var53 = new java.lang.Double((-1.0d));
    java.lang.Double var54 = new java.lang.Double(0.0d);
    java.lang.Double var55 = new java.lang.Double((-1.0d));
    double[] var56 = new double[] {var53, var54, var55};
    org.apache.commons.math.linear.ArrayRealVector var57 =
        new org.apache.commons.math.linear.ArrayRealVector(var56);
    java.lang.Double var58 = new java.lang.Double((-1.0d));
    java.lang.Double var59 = new java.lang.Double(0.0d);
    java.lang.Double var60 = new java.lang.Double((-1.0d));
    double[] var61 = new double[] {var58, var59, var60};
    org.apache.commons.math.linear.ArrayRealVector var62 =
        new org.apache.commons.math.linear.ArrayRealVector(var61);
    org.apache.commons.math.linear.RealVector var63 =
        var57.ebeDivide((org.apache.commons.math.linear.RealVector) var62);
    org.apache.commons.math.linear.RealVector var64 = var57.mapLog10ToSelf();
    java.lang.Double var65 = new java.lang.Double(1.0d);
    org.apache.commons.math.linear.RealVector var66 = var57.mapMultiplyToSelf((double) var65);
    double var67 = org.apache.commons.math.util.MathUtils.indicator((double) var65);
    java.lang.Double var68 = new java.lang.Double((-1.0d));
    java.lang.Double var69 = new java.lang.Double(10.0d);
    java.lang.Double var70 = new java.lang.Double(100.0d);
    int var71 =
        org.apache.commons.math.util.MathUtils.compareTo(
            (double) var68, (double) var69, (double) var70);
    double var72 =
        org.apache.commons.math.util.MathUtils.normalizeAngle((double) var65, (double) var69);
    java.lang.Integer var73 = new java.lang.Integer(10);
    java.lang.Integer var74 = new java.lang.Integer(10);
    double var75 =
        org.apache.commons.math.util.MathUtils.binomialCoefficientLog((int) var73, (int) var74);
    java.lang.Integer var76 = new java.lang.Integer(0);
    java.lang.Long var77 = new java.lang.Long(100L);
    int var78 = org.apache.commons.math.util.MathUtils.pow((int) var76, (long) var77);
    double var79 =
        org.apache.commons.math.util.MathUtils.binomialCoefficientLog((int) var74, (int) var76);
    boolean var80 =
        org.apache.commons.math.util.MathUtils.equalsIncludingNaN(
            (double) var49, (double) var69, (int) var76);
    org.apache.commons.math.linear.RealVector var81 = var46.mapMultiplyToSelf((double) var49);
    org.apache.commons.math.linear.RealVector var82 = var7.mapPow((double) var49);

    // Checks the contract:  equals-hashcode on var23 and var45
    assertTrue(
        "Contract failed: equals-hashcode on var23 and var45",
        var23.equals(var45) ? var23.hashCode() == var45.hashCode() : true);

    // Checks the contract:  equals-hashcode on var45 and var23
    assertTrue(
        "Contract failed: equals-hashcode on var45 and var23",
        var45.equals(var23) ? var45.hashCode() == var23.hashCode() : true);
  }
Ejemplo n.º 6
0
  /**
   * Gift unwrapping (e.g. dig) concept, taking a convex hull and a set of inner points, add inner
   * points to the hull without violating hull invariants--all points must reside on the hull or
   * inside the hull. Based on: Jin-Seo Park and Se-Jong Oh. "A New Concave Algorithm and
   * Concaveness Measure for n-dimensional Datasets" . Department of Nanobiomedical Science. Dankook
   * University". 2010.
   *
   * <p>Per the paper, N = concaveThreshold.
   *
   * <p>This algorithm evaluates remarkably faster than Park and Oh, but the quality of the result
   * is marginally less. If it is acceptable to have some small number of points fall outside of the
   * hull and speed is critical, use this method. The measure of error is difficult to calculate
   * since it is not directly calculated based on the number of inner points. Rather, the measure is
   * based on some number of points in proximity the optimal concave hull.
   *
   * @param geometry
   * @param providedInnerPoints
   * @return
   */
  public Geometry concaveHull(
      final Geometry geometry, final Collection<Coordinate> providedInnerPoints) {
    final Set<Coordinate> innerPoints =
        (providedInnerPoints instanceof Set)
            ? (Set<Coordinate>) providedInnerPoints
            : new HashSet<Coordinate>(providedInnerPoints);
    final TreeSet<Edge> edges = new TreeSet<Edge>();
    final Coordinate[] geoCoordinateList = geometry.getCoordinates();
    final int s = geoCoordinateList.length - 1;
    final Edge firstEdge =
        createEdgeWithSideEffects(geoCoordinateList[0], geoCoordinateList[1], innerPoints, edges);
    Edge lastEdge = firstEdge;
    for (int i = 1; i < s; i++) {
      final Edge newEdge =
          createEdgeWithSideEffects(
              geoCoordinateList[i], geoCoordinateList[i + 1], innerPoints, edges);
      newEdge.connectLast(lastEdge);
      lastEdge = newEdge;
    }
    firstEdge.connectLast(lastEdge);
    for (final Coordinate candidate : innerPoints) {
      double min = Double.MAX_VALUE;
      Edge bestEdge = null;
      for (final Edge edge : edges) {
        final double dist = calcDistance(edge.start, edge.end, candidate);
        if ((dist > 0) && (dist < min)) {
          min = dist;
          bestEdge = edge;
        }
      }
      if (bestEdge != null) {
        bestEdge.getPoints().add(new NeighborData<Coordinate>(candidate, null, min));
      }
    }
    while (!edges.isEmpty()) {
      final Edge edge = edges.pollLast();
      lastEdge = edge;
      NeighborData<Coordinate> candidate = edge.getPoints().pollFirst();
      while (candidate != null) {
        if (!MathUtils.equals(candidate.getDistance(), 0.0, 0.000000001)) {
          final Coordinate selectedCandidate = candidate.getElement();
          final double eh = edge.distance;
          final double startToCandidate =
              distanceFnForCoordinate.measure(edge.start, selectedCandidate);
          final double endToCandidate =
              distanceFnForCoordinate.measure(edge.end, selectedCandidate);
          final double min = Math.min(startToCandidate, endToCandidate);
          // protected against duplicates
          if ((eh / min) > concaveThreshold) {
            final Edge newEdge1 = new Edge(edge.start, selectedCandidate, startToCandidate);
            final Edge newEdge2 = new Edge(selectedCandidate, edge.end, endToCandidate);
            edges.add(newEdge2);
            edges.add(newEdge1);
            newEdge1.connectLast(edge.last);
            newEdge2.connectLast(newEdge1);
            edge.next.connectLast(newEdge2);
            lastEdge = newEdge1;
            for (final NeighborData<Coordinate> otherPoint : edge.getPoints()) {
              final double[] distProfile1 =
                  calcDistanceSegment(newEdge1.start, newEdge1.end, otherPoint.getElement());
              final double[] distProfile2 =
                  calcDistanceSegment(newEdge2.start, newEdge2.end, otherPoint.getElement());
              if (distProfile1[0] >= 0.0 && distProfile1[0] <= 1.0) {
                if (distProfile1[0] < 0.0
                    || distProfile1[0] > 1.0
                    || distProfile2[1] > distProfile1[1]) {
                  otherPoint.setDistance(distProfile1[1]);
                  newEdge1.getPoints().add(otherPoint);
                } else {
                  otherPoint.setDistance(distProfile2[1]);
                  newEdge2.getPoints().add(otherPoint);
                }
              } else if (distProfile2[0] >= 0.0 && distProfile2[0] <= 1.0) {

                otherPoint.setDistance(distProfile2[1]);
                newEdge2.getPoints().add(otherPoint);
              }
            }
            edge.getPoints().clear(); // forces this loop to end
          }
        }
        candidate = edge.getPoints().pollFirst();
      }
    }
    return geometry.getFactory().createPolygon(reassemble(lastEdge));
  }
Ejemplo n.º 7
0
  /**
   * Gift unwrapping (e.g. dig) concept, taking a convex hull and a set of inner points, add inner
   * points to the hull without violating hull invariants--all points must reside on the hull or
   * inside the hull. Based on: Jin-Seo Park and Se-Jong Oh. "A New Concave Algorithm and
   * Concaveness Measure for n-dimensional Datasets" . Department of Nanobiomedical Science. Dankook
   * University". 2010.
   *
   * <p>Per the paper, N = concaveThreshold
   *
   * @param geometry
   * @param providedInnerPoints
   * @return
   */
  public Geometry concaveHullParkOhMethod(
      final Geometry geometry, final Collection<Coordinate> providedInnerPoints) {

    final Set<Coordinate> innerPoints = new HashSet<Coordinate>(providedInnerPoints);
    final TreeSet<Edge> edges = new TreeSet<Edge>();
    final Coordinate[] geoCoordinateList = geometry.getCoordinates();
    final int s = geoCoordinateList.length - 1;
    final Edge firstEdge =
        createEdgeWithSideEffects(geoCoordinateList[0], geoCoordinateList[1], innerPoints, edges);
    Edge lastEdge = firstEdge;
    for (int i = 1; i < s; i++) {
      final Edge newEdge =
          createEdgeWithSideEffects(
              geoCoordinateList[i], geoCoordinateList[i + 1], innerPoints, edges);
      newEdge.connectLast(lastEdge);
      lastEdge = newEdge;
    }
    firstEdge.connectLast(lastEdge);
    while (!edges.isEmpty() && !innerPoints.isEmpty()) {
      final Edge edge = edges.pollLast();
      lastEdge = edge;
      double score = Double.MAX_VALUE;
      Coordinate selectedCandidate = null;
      for (final Coordinate candidate : innerPoints) {
        final double dist = calcDistance(edge.start, edge.end, candidate);
        // on the hull
        if (MathUtils.equals(dist, 0.0, 0.000000001)) {
          score = 0.0;
          selectedCandidate = candidate;
          break;
        }
        if ((dist > 0) && (dist < score)) {
          score = dist;
          selectedCandidate = candidate;
        }
      }
      if (selectedCandidate == null) {
        continue;
      }
      // if one a line segment of the hull, then remove candidate
      if (score == 0.0) {
        innerPoints.remove(selectedCandidate);
        edges.add(edge);
        continue;
      }
      // Park and Oh look only at the neighbor edges
      // but this fails in some cases.
      if (isCandidateCloserToAnotherEdge(score, edge, edges, selectedCandidate)) {
        continue;
      }

      innerPoints.remove(selectedCandidate);
      final double eh = edge.distance;
      final double startToCandidate =
          distanceFnForCoordinate.measure(edge.start, selectedCandidate);
      final double endToCandidate = distanceFnForCoordinate.measure(edge.end, selectedCandidate);
      final double min = Math.min(startToCandidate, endToCandidate);
      // protected against duplicates
      if ((eh / min) > concaveThreshold) {
        final Edge newEdge1 = new Edge(edge.start, selectedCandidate, startToCandidate);
        final Edge newEdge2 = new Edge(selectedCandidate, edge.end, endToCandidate);
        // need to replace this with something more intelligent. This
        // occurs in cases of sharp angles. An angular approach may also
        // work
        // look for an angle to flip in the reverse direction.
        if (!intersectAnotherEdge(newEdge1, edge)
            && !intersectAnotherEdge(newEdge2, edge)
            && !intersectAnotherEdge(newEdge1, edge.last)
            && !intersectAnotherEdge(newEdge2, edge.next)) {
          edges.add(newEdge2);
          edges.add(newEdge1);
          newEdge1.connectLast(edge.last);
          newEdge2.connectLast(newEdge1);
          edge.next.connectLast(newEdge2);
          lastEdge = newEdge1;
        }
      }
    }
    return geometry.getFactory().createPolygon(reassemble(lastEdge));
  }