}   if (newRep == null) { LinearPrinter.println(" transform unsuccessful. stop.");
    public void postVisitSplitJoin(SIRSplitJoin self, SIRSplitJoinIter iter) {	this.splitJoinsSeen++;	SIRSplitter splitter = self.getSplitter();	SIRJoiner   joiner   = self.getJoiner();	int[] splitWeights   = splitter.getWeights();	int[] joinWeights    = joiner.getWeights();		LinearPrinter.println("Visiting SplitJoin (" + self + ")");	LinearPrinter.println(" splitter: " + splitter.getType() +			      makeStringFromIntArray(splitWeights));	LinearPrinter.println(" joiner: " + joiner.getType() + 			      makeStringFromIntArray(joinWeights));	Iterator childIter = self.getChildren().iterator();	while(childIter.hasNext()) {	    SIROperator currentChild = (SIROperator)childIter.next();	    if (currentChild instanceof SIRStream) {		boolean childLinearity = this.hasLinearRepresentation((SIRStream)currentChild);		LinearPrinter.println(" child: " + currentChild + "(" +				      (childLinearity ? "linear" : "non-linear") +				      ")");	    } else {		LinearPrinter.println(" child: " + currentChild);	    }	}	// first things first -- for each child we need a linear rep, so	// iterate through all children and create a parallel list	// of linear representations. Remember that the first two elements	// are the splitter and the joiner so we get rid of them right off the	// bat.	LinkedList repList = new LinkedList();	List childList = self.getChildren();	childList.remove(0); childList.remove(childList.size()-1); // remove the splitter and the joiner	childIter = childList.iterator();	while (childIter.hasNext()) {	    SIRStream currentChild = (SIRStream)childIter.next();	    boolean childLinearity = this.hasLinearRepresentation(currentChild);	    // if we have a linear rep, add it to our list, otherwise we are done	    if (childLinearity) {		repList.add(this.getLinearRepresentation(currentChild));	    } else {		LinearPrinter.println(" aborting split join combination  -- non-linear child detected.");		return;	    }	}	    				  	// the transform that we will set based on the splitter type.	LinearTransform sjTransform = null;		// dispatch based on the splitter 	if (splitter.getType() == SIRSplitType.DUPLICATE) {	    // process duplicate splitter	    sjTransform = LinearTransformSplitJoin.calculateDuplicate(repList, joinWeights);	} else if ((splitter.getType() == SIRSplitType.WEIGHTED_RR) ||		   (splitter.getType() == SIRSplitType.ROUND_ROBIN)) {	    // process roundrobin splitter	    sjTransform = LinearTransformSplitJoin.calculateRoundRobin(repList, joinWeights, splitWeights);	} else if (splitter.getType() == SIRSplitType.NULL) {	    LinearPrinter.println(" Ignoring null splitter.");	} else {	    LinearPrinter.println(" Ignoring unknown splitter type: " + splitter.getType());	}	// if we don't have a transform, we are done and return here	if (sjTransform == null) {  	    LinearPrinter.println(" no transform found. stop");	    return;	}	// do the actual transform	LinearPrinter.println(" performing transform.");	LinearFilterRepresentation newRep = null;	try {	    newRep = sjTransform.transform();	} catch (NoTransformPossibleException e) {	    LinearPrinter.println(" error performing transform: " + e.getMessage());	}	// If the new rep is null, some error occured and we are done	if (newRep == null) {	    LinearPrinter.println(" transform unsuccessful. stop.");	    return;	}		LinearPrinter.println(" transform successful.");	// check for debugging so we don't waste time producing output if not needed	if (LinearPrinter.getOutput()) {	    LinearPrinter.println("Linear splitjoin found: " + self +				  "\n-->Matrix:\n" + newRep.getA() +				  "\n-->Constant Vector:\n" + newRep.getb());	}	// add a mapping from this split join to the new linear representation	this.filtersToLinearRepresentation.put(self, newRep);    }