예제 #1
0
 // an attempt for performance improvement: but does not seem faster for now
 public static RInt expandXVectorCacheFriendly(IntImpl xarg, int xsize, int count) {
     int nsize = xsize * count;
     int[] x = xarg.getContent();
     int[] res = new int[nsize];
     int offset = 0;
     int rep = 0;
     int lastOffset = 0;
     if (rep < count) {
         System.arraycopy(x, 0, res, offset, xsize);
         lastOffset = offset;
         offset += xsize;
     }
     for (rep = 1; rep < count; rep++) {
         System.arraycopy(res, lastOffset, res, offset, xsize);
         lastOffset = offset;
         offset += xsize;
     }
     return RInt.RIntFactory.getFor(res);
 }
예제 #2
0
 public static RInt expandXVector(IntImpl xarg, int xsize, int count) {
     int nsize = xsize * count;
     int[] x = xarg.getContent();
     int[] res = new int[nsize];
     int offset = 0;
     for (int rep = 0; rep < count; rep++) {
         System.arraycopy(x, 0, res, offset, xsize);
         offset += xsize;
     }
     return RInt.RIntFactory.getFor(res);
 }
예제 #3
0
 public static RDouble expandXVector(DoubleImpl xarg, int xsize, int count) {
     int nsize = xsize * count;
     double[] x = xarg.getContent();
     double[] res = new double[nsize];
     int offset = 0;
     for (int rep = 0; rep < count; rep++) {
         System.arraycopy(x, 0, res, offset, xsize);
         offset += xsize;
     }
     return RDouble.RDoubleFactory.getFor(res);
 }
예제 #4
0
파일: RDouble.java 프로젝트: nunb/fastr
    public static double[] copyAsDoubleArray(RDouble d) {
      int size = d.size();
      if (size == 1) {
        return new double[] {d.getDouble(0)};
      } else {
        double[] res = new double[size];

        if (d instanceof DoubleImpl) {
          System.arraycopy(((DoubleImpl) d).getContent(), 0, res, 0, size);
        } else {
          for (int i = 0; i < size; i++) {
            res[i] = d.getDouble(i);
          }
        }
        return res;
      }
    }
예제 #5
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
        }
예제 #6
0
파일: ReadArray.java 프로젝트: nunb/fastr
    @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);
      }
    }