@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);
}
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;
}
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;
}
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
}
@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;
}
