public static boolean validateOverhangs(ArrayList<RGraph> graphs) {
boolean valid = true;
for (RGraph graph : graphs) {
ArrayList<RNode> queue = new ArrayList<RNode>();
HashSet<RNode> seenNodes = new HashSet<RNode>();
RNode root = graph.getRootNode();
queue.add(root);
while (!queue.isEmpty()) {
RNode current = queue.get(0);
queue.remove(0);
seenNodes.add(current);
if (!("EX".equals(current.getLOverhang()) && "SP".equals(current.getROverhang()))) {
return false;
}
ArrayList<RNode> neighbors = current.getNeighbors();
for (RNode neighbor : neighbors) {
if (!seenNodes.contains(neighbor)) {
queue.add(neighbor);
}
}
}
}
return valid;
}
/** Determine overhang scars * */
private void assignScars(ArrayList<RGraph> optimalGraphs) {
// Loop through each optimal graph and grab the root node to prime for the traversal
for (RGraph graph : optimalGraphs) {
RNode root = graph.getRootNode();
ArrayList<RNode> children = root.getNeighbors();
assignScarsHelper(root, children);
}
}
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>");
}
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;
}
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;
}
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);
}
}
@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);
}
}
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);
}
}
private int countLeafs(RNode n) {
if (n.isLeaf()) return 1;
int res = 0;
for (RNode c : n.children) {
res += countLeafs(c);
}
return res;
}
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();
}
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);
}
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;
}
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;
}
/**
* 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);
}
/**
* 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));
}
/**
* This helper method executes the loops necessary to enforce overhangs for each graph in
* enforceOverhangRules *
*/
private void assignBioBricksOverhangsHelper(
RNode parent,
ArrayList<RNode> children,
RNode root,
HashMap<Integer, RVector> stageRVectors) {
// Loop through each one of the children to assign rule-instructed overhangs... enumerated
// numbers currently
for (int i = 0; i < children.size(); i++) {
RNode child = children.get(i);
// Give biobricks overhangs
RVector vector = stageRVectors.get(child.getStage() % stageRVectors.size());
RVector newVector = new RVector("EX", "SP", -1, vector.getName(), null);
child.setVector(newVector);
child.setLOverhang("EX");
child.setROverhang("SP");
// Make recursive call
if (child.getStage() > 0) {
ArrayList<RNode> grandChildren = new ArrayList<RNode>();
grandChildren.addAll(child.getNeighbors());
// Remove the current parent from the list
if (grandChildren.contains(parent)) {
grandChildren.remove(parent);
}
assignBioBricksOverhangsHelper(child, grandChildren, root, stageRVectors);
// Or record the level zero parts
} else {
ArrayList<RNode> l0nodes = _rootBasicNodeHash.get(root);
l0nodes.add(child);
_rootBasicNodeHash.put(root, l0nodes);
}
}
}
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;
}
/**
* 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);
}
@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);
}
}
/**
* First step of overhang assignment - enforce numeric place holders for overhangs, ie no overhang
* redundancy in any step *
*/
private void assignBioBricksOverhangs(
ArrayList<RGraph> optimalGraphs, HashMap<Integer, Vector> stageVectors) {
// Initialize fields that record information to save complexity for future steps
_rootBasicNodeHash = new HashMap<RNode, ArrayList<RNode>>();
HashMap<Integer, RVector> stageRVectors = new HashMap<Integer, RVector>();
for (Integer stage : stageVectors.keySet()) {
RVector vec = ClothoReader.vectorImportClotho(stageVectors.get(stage));
stageRVectors.put(stage, vec);
}
// If the stageVector hash is empty, make a new default vector
if (stageRVectors.size() == 1) {
if (stageRVectors.get(1) == null) {
stageRVectors.put(0, new RVector("EX", "SP", -1, "pSK1A2", null));
}
}
// Loop through each optimal graph and grab the root node to prime for the traversal
for (RGraph graph : optimalGraphs) {
RNode root = graph.getRootNode();
RVector vector = stageRVectors.get(root.getStage() % stageRVectors.size());
RVector rootVector = new RVector("EX", "SP", -1, vector.getName(), null);
root.setVector(rootVector);
root.setLOverhang("EX");
root.setROverhang("SP");
ArrayList<RNode> l0nodes = new ArrayList<RNode>();
_rootBasicNodeHash.put(root, l0nodes);
ArrayList<RNode> neighbors = root.getNeighbors();
assignBioBricksOverhangsHelper(root, neighbors, root, stageRVectors);
}
// Determine which nodes impact which level to form the stageDirectionAssignHash
for (RGraph graph : optimalGraphs) {
RNode root = graph.getRootNode();
ArrayList<String> rootDir = new ArrayList<String>();
ArrayList<String> direction = root.getDirection();
rootDir.addAll(direction);
ArrayList<RNode> l0Nodes = _rootBasicNodeHash.get(root);
// Determine which levels each basic node impacts
for (int i = 0; i < l0Nodes.size(); i++) {
// Determine direction of basic level 0 nodes
RNode l0Node = l0Nodes.get(i);
String l0Direction = rootDir.get(0);
if (l0Node.getComposition().size() == 1) {
ArrayList<String> l0Dir = new ArrayList<String>();
l0Dir.add(l0Direction);
l0Node.setDirection(l0Dir);
}
int size = l0Node.getDirection().size();
rootDir.subList(0, size).clear();
}
}
}
@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);
}
}
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
}
public int countNodes() {
return root.countNodes();
}
public void cleanVisitedNodes() {
root.cleanVisitedNodes();
visitedNodes = BigInteger.ZERO;
}
/** Overhang scars helper * */
private ArrayList<String> assignScarsHelper(RNode parent, ArrayList<RNode> children) {
ArrayList<String> scars = new ArrayList<String>();
// Loop through each one of the children to assign rule-instructed overhangs... enumerated
// numbers currently
for (int i = 0; i < children.size(); i++) {
RNode child = children.get(i);
if (i > 0) {
if (child.getLOverhang().isEmpty()) {
scars.add("_");
}
scars.add("BB");
}
// Make recursive call
if (child.getStage() > 0) {
// Remove the current parent from the list
ArrayList<RNode> grandChildren = new ArrayList<RNode>();
grandChildren.addAll(child.getNeighbors());
if (grandChildren.contains(parent)) {
grandChildren.remove(parent);
}
ArrayList<String> childScars = assignScarsHelper(child, grandChildren);
scars.addAll(childScars);
} else {
ArrayList<String> childScars = new ArrayList<String>();
if (child.getComposition().size() > 1) {
if (!child.getScars().isEmpty()) {
childScars.addAll(child.getScars());
} else {
for (int j = 0; j < child.getComposition().size() - 1; j++) {
childScars.add("_");
}
child.setScars(childScars);
}
}
scars.addAll(childScars);
}
}
// Keep scars for re-used parts with scars
if (!scars.isEmpty()) {
parent.setScars(scars);
return scars;
} else {
return parent.getScars();
}
}
/** Generation of new BioBricks primers for parts * */
public static String[] generatePartPrimers(
RNode node,
Collector coll,
Double meltingTemp,
Integer targetLength,
Integer minPCRLength,
Integer maxPrimerLength) {
// initialize primer parameters
String[] oligos = new String[2];
String partPrimerPrefix = "gaattcgcggccgcttctagag";
String partPrimerSuffix = "tactagtagcggccgctgcag";
String partPrimerPrefixAlt = "gaattcgcggccgcttctag";
String forwardOligoSequence;
String reverseOligoSequence;
Part currentPart = coll.getPart(node.getUUID(), true);
String seq = currentPart.getSeq();
ArrayList<String> type = node.getType();
String fwdHomology;
String revHomology;
// If the part is sufficiently large
if (seq.length() > minPCRLength) {
// Special case primers for coding sequences
if (type.get(0).equals("gene") || type.get(0).equals("reporter")) {
fwdHomology =
seq.substring(
0,
Math.min(
seq.length(),
PrimerDesign.getPrimerHomologyLength(
meltingTemp, targetLength, maxPrimerLength - 20, minPCRLength, seq, true)));
revHomology =
seq.substring(
Math.max(
0,
currentPart.getSeq().length()
- PrimerDesign.getPrimerHomologyLength(
meltingTemp,
targetLength,
maxPrimerLength - 21,
minPCRLength,
PrimerDesign.reverseComplement(seq),
true)));
forwardOligoSequence = partPrimerPrefixAlt + fwdHomology;
reverseOligoSequence = PrimerDesign.reverseComplement(revHomology + partPrimerSuffix);
} else {
if (seq.equals("")) {
fwdHomology = "[ PART " + currentPart.getName() + " HOMOLOGY REGION ]";
revHomology = "[ PART " + currentPart.getName() + " HOMOLOGY REGION ]";
} else {
fwdHomology =
seq.substring(
0,
Math.min(
seq.length(),
PrimerDesign.getPrimerHomologyLength(
meltingTemp,
targetLength,
maxPrimerLength - 22,
minPCRLength,
seq,
true)));
revHomology =
seq.substring(
Math.max(
0,
currentPart.getSeq().length()
- PrimerDesign.getPrimerHomologyLength(
meltingTemp,
targetLength,
maxPrimerLength - 21,
minPCRLength,
PrimerDesign.reverseComplement(seq),
true)));
}
forwardOligoSequence = partPrimerPrefix + fwdHomology;
reverseOligoSequence = PrimerDesign.reverseComplement(revHomology + partPrimerSuffix);
}
// Otherwise make annealing primers or synthesize
} else {
if (type.get(0).equals("gene") || type.get(0).equals("reporter")) {
if (seq.equals("")) {
fwdHomology = "[ PART " + currentPart.getName() + " HOMOLOGY REGION ]";
revHomology = "[ PART " + currentPart.getName() + " HOMOLOGY REGION ]";
forwardOligoSequence = partPrimerPrefixAlt + fwdHomology;
reverseOligoSequence = PrimerDesign.reverseComplement(partPrimerSuffix) + revHomology;
} else {
fwdHomology = seq;
forwardOligoSequence = partPrimerPrefixAlt + fwdHomology + partPrimerSuffix;
reverseOligoSequence = PrimerDesign.reverseComplement(forwardOligoSequence);
}
} else {
if (seq.equals("")) {
fwdHomology = "[ PART " + currentPart.getName() + " HOMOLOGY REGION ]";
revHomology = "[ PART " + currentPart.getName() + " HOMOLOGY REGION ]";
forwardOligoSequence = partPrimerPrefix + fwdHomology;
reverseOligoSequence = PrimerDesign.reverseComplement(partPrimerSuffix) + revHomology;
} else {
fwdHomology = seq;
forwardOligoSequence = partPrimerPrefix + fwdHomology + partPrimerSuffix;
reverseOligoSequence = PrimerDesign.reverseComplement(forwardOligoSequence);
}
}
}
oligos[0] = forwardOligoSequence;
oligos[1] = reverseOligoSequence;
return oligos;
}
@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);
}
};
}
@Override
public final Object execute(Frame frame) {
RAny leftValue = (RAny) left.execute(frame);
RAny rightValue = (RAny) right.execute(frame);
return execute(leftValue, rightValue);
}
