Ejemplo n.º 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;
    }
Ejemplo n.º 2
0
 @Override
 protected <N extends RNode> N replaceChild(RNode oldNode, N newNode) {
     assert oldNode != null;
     if (callNode == oldNode) {
         callNode = newNode;
         return adoptInternal(newNode);
     }
     assert Utils.check(oldNode != callableProvider); // this not must not be rewritten
     assert Utils.check(oldNode != xArgProvider);
     assert Utils.check(oldNode != yArgProvider);
     return super.replaceChild(oldNode, newNode);
 }
Ejemplo n.º 3
0
 public static <T extends RArray> T trace(RArray orig) {
   if (VIEW_TRACING) {
     RArray res;
     if (orig instanceof RList) {
       res = new RListTracingView((RList) orig);
     } else if (orig instanceof RString) {
       res = new RStringTracingView((RString) orig);
     } else if (orig instanceof RComplex) {
       res = new RComplexTracingView((RComplex) orig);
     } else if (orig instanceof RDouble) {
       res = new RDoubleTracingView((RDouble) orig);
     } else if (orig instanceof RInt) {
       res = new RIntTracingView((RInt) orig);
     } else if (orig instanceof RLogical) {
       res = new RLogicalTracingView((RLogical) orig);
     } else if (orig instanceof RRaw) {
       res = new RRawTracingView((RRaw) orig);
     } else {
       assert Utils.check(false, "missed view type");
       res = orig;
     }
     return (T) res;
   } else {
     return (T) orig;
   }
 }
Ejemplo n.º 4
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);
      }
    }
Ejemplo n.º 5
0
 private static Field[] getAllFields(Class cls) {
   ArrayList<Field> res = new ArrayList<>();
   Class c = cls;
   while (c != View.class) {
     assert Utils.check(c != null);
     res.addAll(Arrays.asList(c.getDeclaredFields()));
     c = c.getSuperclass();
   }
   return res.toArray(new Field[res.size()]);
 }
Ejemplo n.º 6
0
    public Site(StackTraceElement[] site) {
      this.site = site;

      int i = 0;
      while (!THIS_FILE_NAME.equals(site[i].getFileName())) {
        i++;
      }
      while (THIS_FILE_NAME.equals(site[i].getFileName())) {
        i++;
      }
      assert Utils.check(i < site.length - 1);
      this.offset = i;
    }
Ejemplo n.º 7
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;
    }
Ejemplo n.º 8
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;
    }
Ejemplo n.º 9
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);
   }
 }
Ejemplo n.º 10
0
 private static void linkChildren(RArray parentRealView, ViewTrace parentTrace) {
   Class viewClass = parentRealView.getClass();
   Field[] fields = getAllFields(viewClass);
   for (Field f : fields) {
     if (f.isSynthetic()) {
       continue;
     }
     Class fieldClass = f.getType();
     if (RArray.class.isAssignableFrom(fieldClass)) {
       try {
         f.setAccessible(true);
         Object o = f.get(parentRealView);
         if (o instanceof TracingView) {
           ((TracingView) o).getTrace().parentView = parentTrace;
         }
       } catch (IllegalAccessException e) {
         assert Utils.check(false, "can't read a view field " + e);
       }
     }
   }
 }
Ejemplo n.º 11
0
 public static ASTNode create(boolean isSuper, ASTNode lhs, ASTNode rhs) {
   if (lhs instanceof SimpleAccessVariable) {
     return writeVariable(isSuper, ((SimpleAccessVariable) lhs).symbol, rhs);
   } else if (lhs instanceof AccessVector) {
     return writeVector(isSuper, (AccessVector) lhs, rhs);
   } else if (lhs instanceof FieldAccess) {
     return writeField(isSuper, (FieldAccess) lhs, rhs);
   } else if (lhs instanceof FunctionCall) {
     return writeFunction(isSuper, (FunctionCall) lhs, rhs);
   } else if (lhs instanceof Constant) { // TODO: move this to the parser?
     RAny value = ((Constant) lhs).getValue();
     if (value instanceof RString) {
       RString svalue = (RString) value;
       if (svalue.size() == 1) {
         String name = svalue.getString(0);
         return writeVariable(isSuper, RSymbol.getSymbol(name), rhs);
       }
     }
     throw RError.getUnknownObject(rhs); // TODO it's own exception
   }
   Utils.nyi();
   return null;
 }
Ejemplo n.º 12
0
public class RContext {

  public static final boolean DEBUG = Utils.getProperty("RConsole.debug.gui", false);
  private static boolean debuggingFormat = false;
  private static boolean usesTruffleOptimizer =
      Truffle.getRuntime().equals("Default Truffle Runtime");
  private static ManageError errorManager = new ManageError(System.err);
  private static Truffleize truffleize = new Truffleize();
  private static final int NCONNECTIONS = 128;
  private static final Connection[] connections = new Connection[NCONNECTIONS];

  static {
    Arrays.fill(connections, null);
  }

  public static boolean usesTruffleOptimizer() {
    return usesTruffleOptimizer;
  }

  public static boolean debuggingFormat() {
    return debuggingFormat;
  }

  public static boolean debuggingFormat(boolean useDebuggingFormat) {
    boolean previous = debuggingFormat;
    debuggingFormat = useDebuggingFormat;
    return previous;
  }

  public static RAny eval(ASTNode expr, boolean useDebuggingFormat) {
    debuggingFormat(useDebuggingFormat);
    return eval(expr);
    // NOTE: cannot reset to the original value of debuggingFormat here, because usually the pretty
    // printer is
    // invoked on the results afterwards by the caller of eval; the pretty printer still depends on
    // the correct
    // setting of debugging format
  }

  public static RAny eval(ASTNode expr) {
    try {
      return (RAny) truffleize.createLazyRootTree(expr).execute(null); // null means top-level
    } catch (RError e) {
      if (DEBUG) {
        e.printStackTrace();
      }
      error(e); // throws an error
    }
    throw new Error("Never reached");
  }

  public static RNode createNode(ASTNode expr) {
    return truffleize.createTree(expr);
  }

  public static RNode createRootNode(ASTNode expr, final RFunction rootEnclosingFunction) {
    return new BaseR(expr) {
      @Child RNode node = adoptChild(truffleize.createTree(ast, rootEnclosingFunction));

      @Override
      public Object execute(Frame frame) {
        return node.execute(frame);
      }
    };
  }

  public static void warning(ASTNode expr, String msg, Object... args) {
    errorManager.warning(expr, String.format(msg, args));
  }

  public static void warning(ASTNode expr, String msg) {
    errorManager.warning(expr, msg);
  }

  public static void warning(RError err) {
    errorManager.warning(err);
  }

  public static void error(ASTNode expr, String msg) {
    errorManager.error(expr, msg);
  }

  public static void error(RError err) {
    errorManager.error(err);
  }

  public static int allocateConnection(Connection connection) {
    for (int i = 0; i < NCONNECTIONS; i++) {
      if (connections[i] == null) {
        connections[i] = connection;
        return i;
      }
    }
    return -1;
  }

  /** Release a connection currently in use. */
  public static void freeConnection(int i) {
    assert Utils.check(connections[i] != null);
    connections[i] = null;
  }

  /** Return a connection or null. */
  public static Connection getConnection(int i) {
    return i >= 0 && i < NCONNECTIONS ? connections[i] : null;
  }

  // note: GNUR currently means not only the GNU-R library, but also some other native code, under
  // licenses compatible with GPL
  private static int hasGNUR = -1;

  public static boolean hasGNUR() {
    if (hasGNUR == -1) {
      try {
        System.loadLibrary("gnurglue");
        hasGNUR = 1;
      } catch (Throwable t) {
        hasGNUR = 0;
      }
    }
    return hasGNUR == 1;
  }

  public static ASTNode parseFile(ANTLRStringStream inputStream) {
    CommonTokenStream tokens = new CommonTokenStream();
    RLexer lexer = new RLexer(inputStream);
    tokens.setTokenSource(lexer);
    RParser parser = new RParser(tokens);

    try {
      return parser.script();
    } catch (RecognitionException e) {
      Console.parseError(parser, e);
      return null;
    }
  }
}
Ejemplo n.º 13
0
 /** Release a connection currently in use. */
 public static void freeConnection(int i) {
   assert Utils.check(connections[i] != null);
   connections[i] = null;
 }
Ejemplo n.º 14
0
    private static void dumpView(int depth, ViewTrace trace) {
      printedIndividualViews.add(trace);

      ps.println(trace.realView + " size = " + trace.realView.size());
      if (TRACE_ALLOCATION_SITE) {
        indent(depth);
        ps.print("    allocationSite =");
        Site.printSite(trace.allocationSite);
        ps.println();
      }

      int unused = trace.unusedElements();
      int redundant = trace.redundantGets();

      boolean singleUse;
      Site[] useSites;

      if (TRACE_USE_SITES) {
        useSites = trace.useSites.toArray(new Site[trace.useSites.size()]);
        singleUse = (useSites.length == 1);
      } else if (TRACE_SINGLE_USE_SITE) {
        useSites = null;
        singleUse = !trace.multipleUseSites;
      } else {
        useSites = null;
        singleUse = false;
      }
      if (singleUse) {
        indent(depth);
        ps.print("    singleUseSite = US");
        Site.printSite(useSites != null ? useSites[0] : trace.singleUseSite);

        if (trace.getCount > 0) {
          ps.println(" (get)");
        } else if (trace.sumCount > 0) {
          ps.println(" (sum)");
        } else {
          ps.println(" (materialize)");
        }

      } else if (trace.getCount > 0) {
        if (TRACE_FIRST_GET_SITE) {
          indent(depth);
          ps.print("    firstGetSite =");
          Site.printSite(trace.firstGetSite);
          ps.println();
        }
        if (trace.materializeCount == 0 && trace.sumCount == 0) {
          if (unused > 0) {
            indent(depth);
            ps.println("    unusedElements = " + unused);
          }
          if (redundant > 0) {
            indent(depth);
            ps.println("    redundantGets = " + redundant + " (no materialize, sum)");
          }
        }
      } else {
        if (trace.materializeCount == 0 && trace.sumCount == 0) {
          indent(depth);
          ps.println("    UNUSED");
        } else {
          indent(depth);
          ps.println(
              "    materializeCount = "
                  + trace.materializeCount
                  + " sumCount = "
                  + trace.sumCount
                  + " getCount = "
                  + trace.getCount);
        }
      }
      if (TRACE_FIRST_MATERIALIZE_SITE && trace.materializeCount > 0 && !singleUse) {
        indent(depth);
        ps.print("    firstMaterializeSite =");
        Site.printSite(trace.firstMaterializeSite);
        ps.println();
      }
      if (TRACE_FIRST_SUM_SITE && trace.sumCount > 0 && !singleUse) {
        indent(depth);
        ps.print("    firstSumSite =");
        Site.printSite(trace.firstSumSite);
        ps.println();
      }
      if (TRACE_USE_SITES) {
        if (useSites.length != 1) {
          indent(depth);
          ps.println("    useSites (" + useSites.length + "):");
          for (Site s : useSites) {
            indent(depth);
            ps.print("        US");
            Site.printSite(s);
            ps.println();
          }
        }
      }

      ps.println();
      RArray view = trace.realView;
      Class viewClass = view.getClass();
      Field[] fields = getAllFields(viewClass);
      boolean printedField = false;

      for (Field f : fields) {
        if (f.isSynthetic()) {
          continue;
        }
        Class fieldClass = f.getType();
        if (RArray.class.isAssignableFrom(fieldClass)) {
          continue; // these later
        }
        indent(depth);
        ps.print("    " + f.getName() + " ");
        try {
          f.setAccessible(true);
          ps.println(f.get(view));
          printedField = true;
        } catch (IllegalAccessException e) {
          assert Utils.check(false, "can't read a view field " + e);
        }
      }

      boolean printNewline = printedField;
      for (Field f : fields) {
        if (f.isSynthetic()) {
          continue;
        }
        Class fieldClass = f.getType();
        if (!RArray.class.isAssignableFrom(fieldClass)) {
          continue;
        }
        if (printNewline) {
          ps.println();
          printNewline = false;
        }
        indent(depth);
        ps.print("    " + f.getName() + " ");
        try {
          f.setAccessible(true);
          Object o = f.get(view);
          if (o instanceof TracingView) {
            ps.print("VIEW ");
            TracingView child = (TracingView) o;
            dumpView(depth + 2, child.getTrace());
          } else {
            ps.print("ARRAY " + o + " size = " + ((RArray) o).size());
            if (o instanceof View) {
              ps.println("MISSED VIEW " + o);
            }
          }
          ps.println();
        } catch (IllegalAccessException e) {
          assert Utils.check(false, "can't read a view field " + e);
        }
      }
    }
Ejemplo n.º 15
0
    private static void extractViewPattern(int depth, ViewTrace trace, StringBuilder p) {
      if (!processedViewsForPatterns.add(trace)) {
        p.append("(ALIASED) ");
      }

      p.append(trace.realView.getClass() + " size = " + trace.realView.size() + "\n");
      indent(depth, p);

      p.append("    use:");
      if (trace.materializeCount == 0 && trace.sumCount == 0 && trace.getCount == 0) {
        p.append(" UNUSED");
      } else {
        if (trace.getCount > 0) {
          p.append(" get");
        }
        if (trace.materializeCount > 0) {
          p.append(" materialize");
        }
        if (trace.sumCount > 0) {
          p.append(" sum");
        }
      }
      p.append("\n");

      if (false) {
        p.append("    allocationSite =");
        Site.printSite(trace.allocationSite, p);
        p.append("\n");
        indent(depth, p);
      }

      RArray view = trace.realView;
      Class viewClass = view.getClass();
      Field[] fields = getAllFields(viewClass);
      boolean printedField = false;

      for (Field f : fields) {
        if (f.isSynthetic()) {
          continue;
        }
        Class fieldClass = f.getType();
        if (RArray.class.isAssignableFrom(fieldClass)) {
          continue; // these later
        }
        indent(depth, p);
        p.append("    " + f.getName() + " ");
        try {
          f.setAccessible(true);
          Object o = f.get(view);
          p.append(o == null ? "null (" + fieldClass + ")" : o.getClass());
          p.append("\n");
          printedField = true;
        } catch (IllegalAccessException e) {
          assert Utils.check(false, "can't read a view field " + e);
        }
      }

      boolean printNewline = printedField;
      for (Field f : fields) {
        if (f.isSynthetic()) {
          continue;
        }
        Class fieldClass = f.getType();
        if (!RArray.class.isAssignableFrom(fieldClass)) {
          continue;
        }
        if (printNewline) {
          p.append("\n");
          printNewline = false;
        }
        indent(depth, p);
        p.append("    " + f.getName() + " ");
        try {
          f.setAccessible(true);
          Object o = f.get(view);
          if (o instanceof TracingView) {
            p.append("VIEW ");
            TracingView child = (TracingView) o;
            extractViewPattern(depth + 2, child.getTrace(), p);
          } else {
            p.append("ARRAY " + o.getClass() + " size = " + ((RArray) o).size());
            if (o instanceof View) {
              ps.println("MISSED VIEW " + o);
            }
          }
          p.append("\n");
        } catch (IllegalAccessException e) {
          assert Utils.check(false, "can't read a view field " + e);
        }
      }
    }
Ejemplo n.º 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
        }
Ejemplo n.º 17
0
    @Override public RNode create(ASTNode call, RSymbol[] names, RNode[] exprs) {
        /*ArgumentInfo ia = */
        check(call, names, exprs);
        if (names.length == 1) {
            return new Builtin.Builtin1(call, names, exprs) {
                @Override public RAny doBuiltIn(Frame frame, RAny xarg) {
                    // x must be matrix-like
                    // method is pearson
                    // use is everything

                    RDouble xd;
                    if (xarg instanceof RDouble || xarg instanceof RInt || xarg instanceof RLogical) {
                        xd = xarg.asDouble().materialize();
                    } else {
                        if (xarg instanceof RArray) {
                            throw RError.getXNumeric(ast);
                        } else {
                            throw RError.getSupplyXYMatrix(ast);
                        }
                    }
                    int[] dim = xd.dimensions();
                    if (dim == null || dim.length != 2) {
                        throw RError.getSupplyXYMatrix(ast);
                    }

                    int nrow = dim[0];
                    int ncol = dim[1];
                    double[] res = new double[ncol * ncol];
                    double[] x = xd.getContent();

                    boolean[] hasNA = new boolean[ncol];
                    boolean anyNA = columnsNAMap(x, nrow, ncol, hasNA);
                    int n1 = nrow - 1;
                    boolean sdZero = false;

                    if (!anyNA) {
                        double[] colMeans = columnMeansNoNA(x, nrow, ncol);
                        for (int i = 0; i < ncol ; i++) {
                            double imean = colMeans[i];
                            int ioffset = i * nrow;
                            for (int j = 0; j <= i; j++) {
                                double jmean = colMeans[j];
                                int joffset = j * nrow;
                                double sum = 0;
                                for (int k = 0; k < nrow; k++) {
                                    sum += (x[ioffset + k] - imean) * (x[joffset + k] - jmean);
                                }
                                double tmp = sum / n1;
                                res[j * ncol + i] = tmp;
                                res[i * ncol + j] = tmp;
                            }
                        }
                        double[] srcov = colMeans;  // colMeans no longer needed
                        for (int i = 0; i < ncol; i++) {
                            srcov[i] = Math.sqrt(res[i * ncol + i]);
                        }
                        for (int i = 0; i < ncol; i++) {
                            for (int j = 0; j < i; j++) {
                                if (srcov[i] == 0 || srcov[j] == 0) {
                                    sdZero = true;
                                    res[j * ncol + i] = RDouble.NA;
                                    res[i * ncol + j] = RDouble.NA;
                                } else {
                                    double tmp = res[i * ncol + j]  / (srcov[i] * srcov[j]);
                                    if (tmp > 1) {
                                        tmp = 1;
                                    }
                                    res[j * ncol + i] = tmp;
                                    res[i * ncol + j] = tmp;
                                }
                            }
                            res[i * ncol + i] = 1;
                        }
                    } else {
                        double[] colMeans = columnMeans(x, nrow, ncol, hasNA);
                        for (int i = 0; i < ncol ; i++) {
                            if (hasNA[i]) {
                                for (int j = 0; j <= i; j++ ) {
                                    res[j * ncol + i] = RDouble.NA; // FIXME: break this into two loops?
                                    res[i * ncol + j] = RDouble.NA;
                                }
                                continue;
                            }
                            double imean = colMeans[i];
                            int ioffset = i * nrow;
                            for (int j = 0; j <= i; j++) {
                                if (hasNA[j]) {
                                    res[j * ncol + i] = RDouble.NA;
                                    res[i * ncol + j] = RDouble.NA;
                                    continue;
                                }
                                double jmean = colMeans[j];
                                int joffset = j * nrow;
                                double sum = 0;
                                for (int k = 0; k < nrow; k++) {
                                    sum += (x[ioffset + k] - imean) * (x[joffset + k] - jmean);
                                }
                                double tmp = sum / n1;
                                res[j * ncol + i] = tmp;
                                res[i * ncol + j] = tmp;
                            }
                        }
                        double[] srcov = colMeans;  // colMeans no longer needed
                        for (int i = 0; i < ncol; i++) {
                            if (!hasNA[i]) {
                                srcov[i] = Math.sqrt(res[i * ncol + i]);
                            }
                        }
                        for (int i = 0; i < ncol; i++) {
                            if (!hasNA[i]) {
                                for (int j = 0; j < i; j++) {
                                    if (srcov[i] == 0 || srcov[j] == 0) {
                                        sdZero = true;
                                        res[j * ncol + i] = RDouble.NA;
                                        res[i * ncol + j] = RDouble.NA;
                                    } else {
                                        double tmp = res[i * ncol + j]  / (srcov[i] * srcov[j]);
                                        if (tmp > 1) {
                                            tmp = 1;
                                        }
                                        res[j * ncol + i] = tmp;
                                        res[i * ncol + j] = tmp;
                                    }
                                }
                            }
                            res[i * ncol + i] = 1;
                        }
                    }
                    if (sdZero) {
                        RContext.warning(ast, RError.SD_ZERO);
                    }
                    return RDouble.RDoubleFactory.getFor(res, new int[] {ncol, ncol}, null);
                }
            };
        }
//        final int xPosition = ia.position("x");
//        final int yPosition = ia.position("y");
//        final int usePosition = ia.position("use");
//        final int methodPosition = ia.position("method");

        Utils.nyi("finish cor");
        return null;
    }
Ejemplo n.º 18
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);
      }
    }
Ejemplo n.º 19
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);
      }
    }
Ejemplo n.º 20
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;
    }