예제 #1
0
 private void visualize(RNode n, java.io.PrintWriter pw, int x0, int y0, int w, int h) {
   pw.printf(
       "<div style=\"position:absolute; left: %d; top: %d; width: %d; height: %d; border: 1px dashed\">\n",
       x0, y0, w, h);
   pw.println("<pre>");
   pw.println("Node: " + n.toString() + " \n(root==" + (n == root) + ") \n");
   pw.println("Coords start: " + Arrays.toString(n.getMbr().getP_start()) + "\n");
   pw.println("coords end: " + Arrays.toString(n.getMbr().getP_end()) + "\n");
   pw.println("# Children: " + ((n.children() == null) ? 0 : n.children().size()) + "\n");
   if (n instanceof REntry) {
     REntry n1 = (REntry) n;
     pw.println("Content: " + n1.getContent());
   }
   pw.println("isLeaf: " + n.isLeaf() + "\n");
   pw.println("</pre>");
   int numChildren = (n.children() == null) ? 0 : n.children().size();
   for (int i = 0; i < numChildren; i++) {
     visualize(
         n.children().get(i),
         pw,
         (int) (x0 + (i * w / (float) numChildren)),
         y0 + elemHeight,
         (int) (w / (float) numChildren),
         h - elemHeight);
   }
   pw.println("</div>");
 }
예제 #2
0
 private RNode getMinimalAreaNode(List<RNode> nodes) {
   RNode minimal = null;
   double minArea = Double.MAX_VALUE;
   for (RNode e : nodes) {
     double eArea = e.getMbr().getArea();
     if (eArea < minArea) {
       minArea = eArea;
       minimal = e;
     }
   }
   return minimal;
 }
예제 #3
0
 private double getDistance(RNode e1, RNode e2) {
   double[] a1 = e1.getMbr().getP_start();
   double[] a2 = e1.getMbr().getP_end();
   double[] b1 = e2.getMbr().getP_start();
   double[] b2 = e2.getMbr().getP_end();
   double dist = 0;
   for (int i = 0; i < dimension; i++) {
     /*suma los cuadrados de la resta de los puntos medios de los 2 mbr's para cada coordenada*/
     dist += Math.pow(Math.abs(a1[i] - a2[i]) / 2.0 - Math.abs(b1[i] - b2[i]) / 2.0, 2);
   }
   dist = Math.sqrt(dist);
   return dist;
 }
예제 #4
0
 private void refresh(RNode part1, RNode part2) throws DimensionalException {
   if (part1 == root) {
     if (part2 != null) {
       // build new root and add children.
       root = makeRoot(false);
       root.addChild(part1);
       part1.setParent(root);
       root.addChild(part2);
       part2.setParent(root);
     }
     update(root);
     return;
   }
   update(part1);
   if (part2 != null) {
     update(part2);
     if (part1.getParent().getChildren().size() > M_order) {
       RNode[] splits = makePartition(part1.getParent());
       refresh(splits[0], splits[1]);
     }
   }
   if (part1.getParent() != null) {
     refresh(part1.getParent(), null);
   }
 }
예제 #5
0
  public void insert(REntry e) throws DimensionalException {

    if (e.getDimension() != dimension)
      throw new DimensionalException(
          "Can only insert n-dimensional objects in n-dimensional RTree");
    RNode theLeaf = findFittingLeaf(root, e);
    theLeaf.children().add(e);
    e.setParent(theLeaf);
    size++;
    // numOfNodes++;
    if (theLeaf.children().size() > M_order) {
      RNode[] parts = makePartition(theLeaf);
      refresh(parts[0], parts[1]);
    } else {
      refresh(theLeaf, null);
    }
  }
예제 #6
0
 private int countLeafs(RNode n) {
   if (n.isLeaf()) return 1;
   int res = 0;
   for (RNode c : n.children) {
     res += countLeafs(c);
   }
   return res;
 }
예제 #7
0
 private double getEnlargement(RNode host, RNode guest) throws DimensionalException {
   double[] p1Host = host.getMbr().getP_start();
   double[] p2Host = host.getMbr().getP_end();
   double[] p1Guest = guest.getMbr().getP_start();
   double[] p2Guest = guest.getMbr().getP_end();
   double[] minRes = new double[dimension];
   double[] maxRes = new double[dimension];
   for (int i = 0; i < dimension; i++) {
     double minH = Math.min(p1Host[i], p2Host[i]);
     double maxH = Math.max(p1Host[i], p2Host[i]);
     double minG = Math.min(p1Guest[i], p2Guest[i]);
     double maxG = Math.max(p1Guest[i], p2Guest[i]);
     if (minG < minH) minRes[i] = minG;
     else minRes[i] = minH;
     if (maxG > maxH) maxRes[i] = maxG;
     else maxRes[i] = maxH;
   }
   return new MBR(minRes, maxRes, dimension).getArea() - host.getMbr().getArea();
 }
예제 #8
0
 private RNode findFittingLeaf(RNode n, REntry e) throws DimensionalException {
   if (n.isLeaf()) return n;
   double min = Double.MAX_VALUE;
   List<RNode> minNodes = new ArrayList<RNode>();
   for (RNode nc : n.children()) {
     double d = getEnlargement(nc, e);
     if (d < min) {
       min = d;
       minNodes.clear();
       minNodes.add(nc);
     } else if (d == min) {
       minNodes.add(nc);
     }
   }
   RNode next;
   if (minNodes.size() > 1) next = getMinimalAreaNode(minNodes);
   else next = minNodes.get(0);
   return findFittingLeaf(next, e);
 }
예제 #9
0
 public List<REntry> search(double[] point, double ratio) throws DimensionalException {
   List<REntry> resultados = new LinkedList<REntry>();
   StringBuilder sb = new StringBuilder();
   if (point.length != dimension)
     throw new DimensionalException("Can only search for n-dimensional points");
   root.search(point, ratio, resultados, sb);
   visitedNodes =
       visitedNodes.add(
           new BigInteger(
               ""
                   + sb.toString()
                       .length())); // visitedNodes.add(root.visitedNodes.add(BigInteger.ONE));
   return resultados;
 }
예제 #10
0
 private RNode[] makePartition(RNode n) throws DimensionalException {
   numOfPartitions++;
   numOfNodes += 2;
   RNode[] parts = new RNode[] {n, new RNode(n.getMbr(), n.isLeaf(), M_order)};
   parts[1].setParent(n.getParent());
   if (parts[1].getParent() != null) {
     parts[1].getParent().children().add(parts[1]);
   }
   List<RNode> cpyc = new LinkedList<RNode>(n.children());
   n.children().clear();
   RNode[] seeds = getSeeds(cpyc);
   parts[0].children().add(seeds[0]);
   parts[1].children().add(seeds[1]);
   update(parts[0]);
   update(parts[1]);
   while (!cpyc.isEmpty()) {
     if (parts[0].missingEntries(m_order) == 0
         && parts[1].missingEntries(m_order) + cpyc.size() == m_order) {
       parts[1].children().addAll(cpyc);
       cpyc.clear();
       update(parts[0]);
       update(parts[1]);
       return parts;
     } else if (parts[1].missingEntries(m_order) == 0
         && parts[0].missingEntries(m_order) + cpyc.size() == m_order) {
       parts[0].children().addAll(cpyc);
       cpyc.clear();
       update(parts[0]);
       update(parts[1]);
       return parts;
     }
     RNode next = chooseNext(cpyc, seeds), chosen;
     double enl1 = getEnlargement(parts[0], next);
     double enl2 = getEnlargement(parts[1], next);
     if (enl1 < enl2) chosen = parts[0];
     else if (enl2 < enl1) chosen = parts[1];
     else {
       double ar1 = parts[0].getMbr().getArea();
       double ar2 = parts[1].getMbr().getArea();
       if (ar1 < ar2) chosen = parts[0];
       else if (ar2 < ar1) chosen = parts[1];
       else {
         if (parts[0].children().size() < parts[1].children().size()) chosen = parts[0];
         else if (parts[0].children().size() > parts[1].children().size()) chosen = parts[1];
         else chosen = parts[new Random().nextInt(2)];
       }
     }
     chosen.children().add(next);
     update(chosen);
   }
   return parts;
 }
예제 #11
0
 /**
  * Administrador de memoria para guardar un nodo, guarda en el bloque que corresponde el nodo que
  * recibe como parametro, si el bloque esta en memoria principal lo guarda directamente, de lo
  * contrario lo carga desde memoria secundaria y el bloque completo queda en memoria.
  *
  * @param nodo nodo que queremos guardar, sera guardado de acuerdo a sus paremetros getFilePos y
  *     getPagePos
  * @throws IOException
  */
 private void writeAdmin(RNode nodo) throws IOException {
   long fPos = nodo.getMyfPos();
   int i;
   for (i = 0; i < numOfBuffers; i++) {
     if (fPos == thisBlock[i]) {
       writeNode(nodo, i);
       return;
     }
   }
   // Guardo el bloque con peor prioridad a memoria secundaria si fue modificado,
   // si no lo fue solo lo sobreescribo
   i = bufferPrior[numOfBuffers - 1];
   if (bufModified[i]) writeBlock(i);
   readBlock(fPos, i);
   writeNode(nodo, i);
 }
예제 #12
0
 /**
  * shrinks the mbr area to the just necessary
  *
  * @param n
  */
 private void update(RNode n) throws DimensionalException {
   double[] minCoords = new double[dimension];
   double[] maxCoords = new double[dimension];
   for (int i = 0; i < dimension; i++) {
     minCoords[i] = Double.MAX_VALUE;
     maxCoords[i] = -Double.MAX_VALUE;
     for (RNode c : n.children()) {
       c.setParent(n);
       double minp = Math.min(c.getMbr().getP_start()[i], c.getMbr().getP_end()[i]);
       double maxp = Math.max(c.getMbr().getP_end()[i], c.getMbr().getP_start()[i]);
       if (minp < minCoords[i]) {
         minCoords[i] = minp;
       }
       if (maxp > maxCoords[i]) {
         maxCoords[i] = maxp;
       }
     }
   }
   n.setMbr(new MBR(minCoords, maxCoords, dimension));
 }
예제 #13
0
 private RNode[] quadSeeds(List<RNode> cc) throws DimensionalException {
   RNode e1;
   RNode e2;
   RNode s1 = null;
   RNode s2 = null;
   double maxDeadSpace = -Double.MAX_VALUE;
   for (int i = 0; i < dimension; i++) {
     for (int k = i + 1; k < dimension; k++) {
       e1 = cc.get(i);
       e2 = cc.get(k);
       double areae1 = e1.getMbr().getArea();
       double areae2 = e2.getMbr().getArea();
       double[] p1Host = e1.getMbr().getP_start();
       double[] p2Host = e1.getMbr().getP_end();
       double[] p1Guest = e2.getMbr().getP_start();
       double[] p2Guest = e2.getMbr().getP_end();
       double[] minRes = new double[dimension];
       double[] maxRes = new double[dimension];
       for (int j = 0; j < dimension; j++) {
         double minH = Math.min(p1Host[j], p2Host[j]);
         double maxH = Math.max(p1Host[j], p2Host[j]);
         double minG = Math.min(p1Guest[j], p2Guest[j]);
         double maxG = Math.max(p1Guest[j], p2Guest[j]);
         if (minG < minH) minRes[j] = minG;
         else minRes[j] = minH;
         if (maxG > maxH) maxRes[j] = maxG;
         else maxRes[j] = maxH;
       }
       MBR ambr = new MBR(minRes, maxRes, dimension);
       double totarea = ambr.getArea();
       if (maxDeadSpace < totarea - areae1 - areae2) {
         maxDeadSpace = totarea - areae1 - areae2;
         s1 = e1;
         s2 = e2;
       }
     }
   }
   RNode[] seeds = new RNode[] {s1, s2};
   cc.removeAll(Arrays.asList(seeds));
   return seeds;
 }
예제 #14
0
 /**
  * Guarda un Node en un buffer en memoria principal
  *
  * @param nodo Node que queremos guardar en el buffer
  * @param pPos posicion en el buffer donde guardaremos el nodo
  * @param i numero de buffer donde guardaremos el nodo (buffer[i]).
  * @throws IOException
  */
 private void writeNode(RNode nodo, int i) throws IOException {
   nodo.writeToBuffer(buffer[i]);
   bufModified[i] = true;
   improvePriority(i);
 }
예제 #15
0
 public int countNodes() {
   return root.countNodes();
 }
예제 #16
0
        public RAny outer(Frame frame, RAny xarg, RAny yarg, RAny farg) {
            // LICENSE: transcribed code from GNU R, which is licensed under GPL

            if (!(xarg instanceof RArray && yarg instanceof RArray)) {
                Utils.nyi("unsupported type");
                return null;
            }

            RArray x = (RArray) xarg;
            RArray y = (RArray) yarg;

            int xsize = x.size();
            int ysize = y.size();

            RArray expy;
            RArray expx;

            if (EAGER) {
                x = x.materialize(); // FIXME: probably unnecessary (both x and y), could be done on-the-fly in the expansion methods
                y = y.materialize();
                if (y instanceof DoubleImpl) {
                    expy = expandYVector((DoubleImpl) y, ysize, xsize);
                } else if (y instanceof IntImpl) {
                    expy = expandYVector((IntImpl) y, ysize, xsize);
                } else {
                    expy = expandYVector(y, ysize, xsize);
                }

                if (xsize > 0) {
                    if (x instanceof DoubleImpl) {
                        expx = expandXVector((DoubleImpl) x, xsize, ysize);
                    } else if (x instanceof IntImpl) {
                        expx = expandXVector((IntImpl) x, xsize, ysize);
                    } else {
                        expx = expandXVector(x, xsize, ysize);
                    }
                } else {
                    expx = x;
                }
            } else {
                if (y instanceof RInt) {
                    expy = lazyExpandYVector((RInt) y, ysize, xsize);
                } else {
                    throw Utils.nyi();
                }
                if (xsize > 0) {
                    if (x instanceof RInt) {
                        expx = lazyExpandXVector((RInt) x, xsize, ysize);
                    } else {
                        throw Utils.nyi();
                    }
                } else {
                    expx = x;
                }
            }

            xArgProvider.setValue(expx);
            yArgProvider.setValue(expy);
            callableProvider.matchAndSet(frame, farg);
            RArray res = (RArray) callNode.execute(frame);

            int[] dimx = x.dimensions();
            int[] dimy = y.dimensions();

            int[] dim;
            if (dimx == null) {
                if (dimy == null) {
                    dim = new int[]{xsize, ysize};
                } else {
                    dim = new int[1 + dimy.length];
                    dim[0] = xsize;
                    System.arraycopy(dimy, 0, dim, 1, dimy.length);
                }
            } else {
                if (dimy == null) {
                    dim = new int[dimx.length + 1];
                    System.arraycopy(dimx, 0, dim, 0, dimx.length);
                    dim[dimx.length] = ysize;
                } else {
                    dim = new int[dimx.length + dimy.length];
                    System.arraycopy(dimx, 0, dim, 0, dimx.length);
                    System.arraycopy(dimy, 0, dim, dimx.length, dimy.length);
                }
            }
            return res.setDimensions(dim); // triggers materialization of the result
        }
예제 #17
0
    @Override public RNode create(ASTNode call, RSymbol[] names, RNode[] exprs) {
        ArgumentInfo ia = check(call, names, exprs);
        boolean product = false;
        if (ia.provided("FUN")) {
            RNode fnode = exprs[ia.position("FUN")];
            if (fnode instanceof Constant) {
                RAny value = ((Constant) fnode).execute(null);
                if (value instanceof RString) {
                    RString str = (RString) value;
                    if (str.size() == 1) {
                        if (str.getString(0).equals("*")) {
                            product = true;
                        }
                    }
                }
            }
        } else {
            product = true;
        }
        if (product) {
            return new MatrixOperation.OuterProduct(call, exprs[ia.position("X")], exprs[ia.position("Y")]);
        }

        int cnArgs = 2 + names.length - 3; // "-2" because both FUN, X, Y
        RSymbol[] cnNames = new RSymbol[cnArgs];
        RNode[] cnExprs = new RNode[cnArgs];
        cnNames[0] = null;
        ValueProvider xArgProvider = new ValueProvider(call);
        cnExprs[0] = xArgProvider;
        ValueProvider yArgProvider = new ValueProvider(call);
        cnExprs[1] = yArgProvider;
        ValueProvider[] constantArgProviders = new ValueProvider[cnArgs];
        int j = 0;
        for (int i = 0; i < names.length; i++) {
            if (ia.position("X") == i || ia.position("Y") == i || ia.position("FUN") == i) {
                continue;
            }
            cnNames[2 + j] = names[i];
            ValueProvider vp = new ValueProvider(call);
            cnExprs[2 + j] = vp;
            constantArgProviders[j] = vp;
            j++;
        }

        RNode funExpr = exprs[ia.position("FUN")];
        final CallableProvider callableProvider = new CallableProvider(funExpr.getAST(), funExpr);
        final RNode callNode = FunctionCall.getFunctionCall(call, callableProvider, cnNames, cnExprs);
        final int posX = ia.position("X");
        final int posY = ia.position("Y");
        final int posFUN = ia.position("FUN");

        return new OuterBuiltIn(call, names, exprs, callNode, callableProvider, xArgProvider, yArgProvider, constantArgProviders) {
            @Override public RAny doBuiltIn(Frame frame, RAny[] args) {
                RAny argx = null;
                RAny argy = null;
                RAny argfun = null;
                int k = 0;
                for (int i = 0; i < args.length; i++) {
                    if (i == posX) {
                        argx = args[i];
                    } else if (i == posY) {
                        argy = args[i];
                    } else if (i == posFUN) {
                        argfun = args[i];
                    } else {
                        constantArgProviders[k].setValue(args[i]);
                        k++;
                    }
                }
                return outer(frame, argx, argy, argfun);
            }
        };
    }
예제 #18
0
 public void cleanVisitedNodes() {
   root.cleanVisitedNodes();
   visitedNodes = BigInteger.ZERO;
 }