Пример #1
0
    /**
     * Returns the selection array or vector.
     *
     * <p>The selSizes array contains sizes of the selectors (number of elements that will be
     * returned by it). The idx array contains the indices returned by the selectors (that is the
     * indices used to compute the source offset).
     *
     * <p>The selIdx array contains the position in the selector (when this is equal to the selector
     * size the selector has overflown).
     */
    public Object execute(RArray source, boolean drop, int exact) throws UnexpectedResultException {
      int[] sourceDim = source.dimensions();
      boolean mayHaveNA = Selector.initialize(offsets, selectorVals, sourceDim, selSizes, ast);
      int[] destDim = Selector.calculateDestinationDimensions(selSizes, !subset || drop);
      int destSize = Selector.calculateSizeFromSelectorSizes(selSizes);

      RArray dest = Utils.createArray(source, destSize, destDim, null, null); // drop attributes
      if (destSize == 0) {
        return dest;
      }
      int offset = 0;
      for (; ; ) {
        int sourceOffset = offsets[0];
        if (sourceOffset == RInt.NA) {
          Utils.setNA(dest, offset);
        } else {
          dest.set(offset, source.getRef(sourceOffset));
        }
        offset++;
        if (offset < destSize) {
          if (!mayHaveNA) {
            Selector.advanceNoNA(offsets, sourceDim, selectorVals, ast);
          } else {
            Selector.advance(offsets, sourceDim, selectorVals, ast);
          }
        } else {
          break;
        }
      }
      return dest;
    }
Пример #2
0
    @Override
    public Object execute(Frame frame) {

      RAny lhsVal = (RAny) lhs.execute(frame);
      RAny rowVal = (RAny) rowExpr.execute(frame);
      boolean dropVal =
          dropExpr.executeLogical(frame)
              != RLogical.FALSE; // FIXME: what is the correct execution order of these args?
      int exactVal = exactExpr.executeLogical(frame);

      if (!(lhsVal instanceof RArray)) {
        throw RError.getObjectNotSubsettable(ast, lhsVal.typeOf());
      }
      RArray array = (RArray) lhsVal;
      int[] dim = array.dimensions();
      if (dim == null || dim.length != 2) {
        throw RError.getIncorrectDimensions(getAST());
      }
      int m = dim[0];
      int n = dim[1];

      try {
        int row;
        if (rowVal instanceof ScalarIntImpl) {
          row = ((ScalarIntImpl) rowVal).getInt();
        } else if (rowVal instanceof ScalarDoubleImpl) {
          row = Convert.double2int(((ScalarDoubleImpl) rowVal).getDouble());
        } else {
          throw new UnexpectedResultException(null);
        }
        if (row > n || row <= 0) {
          throw new UnexpectedResultException(null);
        }

        int[] ndim;
        if (dropVal) {
          ndim = null;
        } else {
          ndim = new int[] {1, n};
        }

        // note: also could be lazy here
        RArray res = Utils.createArray(array, n, ndim, null, null); // drop attributes
        int offset = row - 1;
        for (int i = 0; i < n; i++) {
          res.set(i, array.getRef(offset));
          offset += m;
        }
        return res;
      } catch (UnexpectedResultException e) {
        SelectorNode selIExpr = Selector.createSelectorNode(ast, true, rowExpr);
        SelectorNode selJExpr = Selector.createSelectorNode(ast, true, null);
        MatrixRead nn = new MatrixRead(ast, true, lhs, selIExpr, selJExpr, dropExpr, exactExpr);
        replace(nn, "install MatrixRead from MatrixRowSubset");
        Selector selI = selIExpr.executeSelector(rowVal);
        Selector selJ = selJExpr.executeSelector(frame);
        return nn.executeLoop(array, selI, selJ, dropVal, exactVal);
      }
    }
Пример #3
0
    public static RArray expandXVector(RArray x, int xsize, int count) {
        int nsize = xsize * count;

        RArray res = Utils.createArray(x, nsize);
        int offset = 0;
        for (int rep = 0; rep < count; rep++) {
            for (int i = 0; i < xsize; i++) {
                res.set(offset + i, x.get(i));
            }
            offset += xsize;
        }
        return res;
    }
Пример #4
0
    public static RArray expandYVector(RArray y, int ysize, int count) {
        int size = ysize;
        int nsize = size * count;

        RArray res = Utils.createArray(y, nsize);
        int offset = 0;
        for (int elem = 0; elem < size; elem++) {
            Object v = y.get(elem);
            for (int i = 0; i < count; i++) {
                res.set(offset + i, v);
            }
            offset += count;
        }
        return res;
    }
Пример #5
0
 @Override
 public Object execute(
     RArray base, Selector selectorI, Selector selectorJ, boolean drop, int exact)
     throws UnexpectedResultException {
   int[] ndim = base.dimensions();
   int m = ndim[0];
   int n = ndim[1];
   selectorI.start(m, ast);
   selectorJ.start(n, ast);
   int i = selectorI.nextIndex(ast);
   int j = selectorJ.nextIndex(ast);
   assert Utils.check(i != RInt.NA && j != RInt.NA); // ensured by subscript selectors
   int offset = j * m + i;
   if (!(base instanceof RList)) {
     return base.boxedGet(offset);
   } else {
     return ((RList) base).getRAny(offset);
   }
 }
Пример #6
0
    @Override
    public Object execute(Frame frame) {
      RAny lhsVal = (RAny) lhs.execute(frame);
      Selector selectorI = selectorIExpr.executeSelector(frame);
      Selector selectorJ = selectorJExpr.executeSelector(frame);
      boolean dropVal =
          dropExpr.executeLogical(frame)
              != 0; // FIXME: what is the correct execution order of these args?
      int exactVal = exactExpr.executeLogical(frame);

      if (!(lhsVal instanceof RArray)) {
        throw RError.getObjectNotSubsettable(ast, lhsVal.typeOf());
      }
      RArray array = (RArray) lhsVal;
      int[] dim = array.dimensions();
      if (dim == null || dim.length != 2) {
        throw RError.getIncorrectDimensions(getAST());
      }
      return executeLoop(array, selectorI, selectorJ, dropVal, exactVal);
    }
Пример #7
0
        public RAny outer(Frame frame, RAny xarg, RAny yarg, RAny farg) {
            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(ast, 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);
        }
Пример #8
0
    @Override
    public Object execute(Frame frame) {

      RAny lhsVal = (RAny) lhs.execute(frame);
      Object rowFromVal = rowFromExpr.execute(frame);
      Object rowToVal = rowToExpr.execute(frame);
      Object colFromVal = colFromExpr.execute(frame);
      Object colToVal = colToExpr.execute(frame);
      boolean dropVal =
          dropExpr.executeLogical(frame)
              != RLogical.FALSE; // FIXME: what is the correct execution order of these args?
      int exactVal = exactExpr.executeLogical(frame);
      if (!(lhsVal instanceof RArray)) {
        throw RError.getObjectNotSubsettable(ast, lhsVal.typeOf());
      }
      RArray array = (RArray) lhsVal;

      try {

        int rowFrom = extractLimit(rowFromVal); // zero-based
        int rowTo = extractLimit(rowToVal);
        int colFrom = extractLimit(colFromVal);
        int colTo = extractLimit(colToVal);

        int[] dim = array.dimensions();
        if (dim == null || dim.length != 2) {
          throw RError.getIncorrectDimensions(getAST());
        }
        int m = dim[0];
        int n = dim[1];

        int rowStep;
        int rowSize;
        if (rowFrom <= rowTo) {
          rowStep = 1;
          if (rowTo > m) {
            throw new UnexpectedResultException(null);
          }
          rowSize = rowTo - rowFrom + 1;
        } else {
          rowStep = -1;
          if (rowFrom > m) {
            throw new UnexpectedResultException(null);
          }
          rowSize = rowFrom - rowTo + 1;
        }

        int colStep;
        int colSize;
        if (colFrom <= colTo) {
          colStep = 1;
          if (colTo > n) {
            throw new UnexpectedResultException(null);
          }
          colSize = colTo - colFrom + 1;
        } else {
          colStep = -1;
          if (colFrom > n) {
            throw new UnexpectedResultException(null);
          }
          colSize = colFrom - colTo + 1;
        }

        int[] ndim;
        if (!dropVal || (rowSize > 1 && colSize > 1)) {
          ndim = new int[] {rowSize, colSize};
        } else {
          ndim = null;
        }

        int size = rowSize * colSize;
        RArray res = Utils.createArray(array, size, ndim, null, null); // drop attributes

        if (colStep == 1 && rowStep == 1) {
          int j = colFrom * m + rowFrom; // j - index to source matrix
          int jmax = j + rowSize;
          int jadvance = m - rowSize;
          for (int i = 0; i < size; i++) {
            res.set(i, array.getRef(j++)); // i - index to target matrix
            if (j == jmax) {
              j += jadvance;
              jmax += m;
            }
          }
        } else {
          int i = 0;
          // NOTE: here we know that colFrom != colTo and rowFrom != rowTo
          for (int col = colFrom; col != colTo + colStep; col += colStep) {
            for (int row = rowFrom; row != rowTo + rowStep; row += rowStep) {
              res.set(i++, array.getRef(col * m + row));
            }
          }
        }
        return res;
      } catch (UnexpectedResultException e) {
        // FIXME: clean this up; does Colon need to be package-private?
        ASTNode rowAST = rowFromExpr.getAST().getParent();
        Builtin rowColon =
            (Builtin)
                Primitives.getCallFactory(RSymbol.getSymbol(":"), null)
                    .create(rowAST, rowFromExpr, rowToExpr);
        SelectorNode selIExpr = Selector.createSelectorNode(rowAST, true, rowColon);
        ASTNode colAST = colFromExpr.getAST().getParent();
        Builtin colColon =
            (Builtin)
                Primitives.getCallFactory(RSymbol.getSymbol(":"), null)
                    .create(colAST, colFromExpr, colToExpr);
        SelectorNode selJExpr = Selector.createSelectorNode(ast, true, colColon);
        MatrixRead nn = new MatrixRead(ast, true, lhs, selIExpr, selJExpr, dropExpr, exactExpr);
        replace(nn, "install MatrixRead from MatrixSequenceSubset");
        Selector selI =
            selIExpr.executeSelector(
                rowColon.doBuiltIn(frame, new RAny[] {(RAny) rowFromVal, (RAny) rowToVal}));
        Selector selJ =
            selJExpr.executeSelector(
                colColon.doBuiltIn(frame, new RAny[] {(RAny) colFromVal, (RAny) colToVal}));
        return nn.executeLoop(array, selI, selJ, dropVal, exactVal);
      }
    }
Пример #9
0
    public Object execute(
        RArray source, Selector selectorI, Selector selectorJ, boolean drop, int exact)
        throws UnexpectedResultException {
      assert Utils.check(subset);
      int[] ndim = source.dimensions();
      int m = ndim[0];
      int n = ndim[1];
      selectorI.start(m, ast);
      selectorJ.start(n, ast);
      int nm = selectorI.size();
      int nn = selectorJ.size();
      boolean mayHaveNA = selectorI.mayHaveNA() || selectorJ.mayHaveNA();
      int nsize = nm * nn;
      if ((nm != 1 && nn != 1) || !drop) {
        ndim = new int[] {nm, nn};
      } else {
        ndim = null;
      }
      RArray res = Utils.createArray(source, nsize, ndim, null, null); // drop attributes
      if (!mayHaveNA) {
        int resoffset = 0;
        for (int nj = 0; nj < nn; nj++) {
          int j = selectorJ.nextIndex(ast);
          int srcoffset = j * m;
          for (int ni = 0; ni < nm; ni++) {
            int i = selectorI.nextIndex(ast);
            Object value =
                source.getRef(
                    srcoffset
                        + i); // FIXME: check overflow? (the same is at many locations, whenever
                              // indexing a matrix)
            res.set(resoffset++, value);
          }
          selectorI.restart();
        }
      } else {
        for (int nj = 0; nj < nn; nj++) {
          int j = selectorJ.nextIndex(ast);
          if (j != RInt.NA) {
            selectorI.restart();
            for (int ni = 0; ni < nm; ni++) {
              int offset = nj * nm + ni;
              int i = selectorI.nextIndex(ast);
              if (i != RInt.NA) {
                Object value;
                value =
                    source.getRef(
                        j * m
                            + i); // FIXME: check overflow? (the same is at many locations, whenever
                                  // indexing a matrix)
                res.set(offset, value);
              } else {
                Utils.setNA(res, offset);
              }
            }
          } else {
            for (int ni = 0; ni < nm; ni++) {
              Utils.setNA(res, nj * nm + ni);
            }
          }
        }
      }

      return res;
    }
Пример #10
0
    @Override
    public Object execute(Frame frame) {

      RAny lhsVal = (RAny) lhs.execute(frame);
      RAny colVal = (RAny) columnExpr.execute(frame);
      boolean dropVal =
          dropExpr.executeLogical(frame)
              != RLogical.FALSE; // FIXME: what is the correct execution order of these args?
      int exactVal = exactExpr.executeLogical(frame);

      // TODO: GNU-R has different behavior when selecting from arrays that have some dimension zero

      if (!(lhsVal instanceof RArray)) {
        throw RError.getObjectNotSubsettable(ast, lhsVal.typeOf());
      }
      RArray array = (RArray) lhsVal;
      int[] dim = array.dimensions();
      if (dim == null || dim.length != nSelectors) {
        throw RError.getIncorrectDimensions(getAST());
      }
      int n = dim[nSelectors - 1]; // limit for the column (last dimension)

      try {
        int col;
        if (colVal instanceof ScalarIntImpl) {
          col = ((ScalarIntImpl) colVal).getInt();
        } else if (colVal instanceof ScalarDoubleImpl) {
          col = Convert.double2int(((ScalarDoubleImpl) colVal).getDouble());
        } else {
          throw new UnexpectedResultException(null);
        }
        if (col > n || col <= 0) {
          throw new UnexpectedResultException(null);
        }

        int[] ndim;
        int m; // size of the result

        if (dropVal) {
          boolean hasNonTrivialDimension = false;
          boolean resultIsVector = true;
          m = 1;
          for (int i = 0; i < nSelectors - 1; i++) {
            int d = dim[i];
            if (d != 1) {
              if (hasNonTrivialDimension) {
                resultIsVector = false;
              } else {
                hasNonTrivialDimension = true;
              }
            }
            m *= d;
          }
          if (resultIsVector) {
            ndim = null;
          } else {
            ndim = new int[nSelectors - 1];
            System.arraycopy(dim, 0, ndim, 0, ndim.length);
          }
        } else {
          ndim = new int[nSelectors];
          ndim[nSelectors - 1] = 1;

          m = 1;
          for (int i = 0; i < ndim.length - 1; i++) {
            int d = dim[i];
            ndim[i] = d;
            m *= d;
          }
        }

        // note: also could be lazy here
        RArray res = Utils.createArray(array, m, ndim, null, null); // drop attributes
        int offset = (col - 1) * m; // note: col is 1-based
        for (int i = 0; i < m; i++) {
          res.set(i, array.getRef(offset + i));
        }
        return res;
      } catch (UnexpectedResultException e) {
        SelectorNode[] selectorExprs = new SelectorNode[nSelectors];
        for (int i = 0; i < nSelectors - 1; i++) {
          selectorExprs[i] = Selector.createSelectorNode(ast, true, null);
        }
        selectorExprs[nSelectors - 1] = Selector.createSelectorNode(ast, true, columnExpr);
        GenericRead gr = new GenericRead(ast, true, lhs, selectorExprs, dropExpr, exactExpr);
        replace(gr, "install GenericRead from ArrayColumnSubset");
        for (int i = 0; i < nSelectors - 1; i++) {
          gr.selectorVals[i] = selectorExprs[i].executeSelector(frame);
        }
        gr.selectorVals[nSelectors - 1] = selectorExprs[nSelectors - 1].executeSelector(colVal);
        return gr.executeLoop(array, dropVal, exactVal);
      }
    }