public static double test( String filename, Vector<Vector<Double>> setOfNodes, String inputRepresentation, int outputRepresentation) { Vector<Double> testError = new Vector<Double>(); int target = 0; String binary = ""; int baseTen = 0; inputs.clear(); firstRead = true; while ((target = readFileIntoInputVector(inputRepresentation)) != -2) { firstRead = false; double minError = 10; int solution = 0; for (int i = 0; i < setOfNodes.size(); i++) { double currentError = testNode(outputRepresentation, target, setOfNodes.get(i)); double absValCurrentError = Math.abs(currentError); if (absValCurrentError < minError) { minError = absValCurrentError; // update minimum error across function if we find a smaller one } if (outputRepresentation == 4) { binary = binary + ((int) (target - currentError)); // fills with binary representation baseTen = Integer.parseInt(binary, 2); } } if (outputRepresentation == 4) { if (target - baseTen == 0) { countCorrect++; } } else if (target - Math.round(minError) == target) { // if error is low enough that we will get the right digit for this node countCorrect++; } baseTen = 0; binary = ""; countTotal++; testError.add(minError); inputs.clear(); } double euclidianDistance = 0; for (double err : testError) { euclidianDistance += Math.pow(err, 2); } euclidianDistance = Math.sqrt(euclidianDistance); System.out.println("Test Mean Squared Error: " + euclidianDistance); System.out.println("Test Percent: " + (100 * (double) countCorrect / (double) countTotal)); return 0; }
/** * Performs a remote tuple space operation. * * @param template * @param dest * @param type * @return The matching tuple or null if none was found. */ private Tuple doMonoOp(Tuple template, int dest, int type) { AgillaTSReqMsgJ request; if (type == REMOVE) request = new AgillaTSReqMsgJ(dest, TOS_UART_ADDRESS, BasicOpcodes.OPrinp, template); else request = new AgillaTSReqMsgJ(dest, TOS_UART_ADDRESS, BasicOpcodes.OPrrdp, template); log("doMonoOp: request = " + request + ", dest = " + dest); response.clear(); try { log("doMonoOp: Sent inp or rdp request."); // results = null; sni.send(request); } catch (IOException e) { e.printStackTrace(); return null; } TimeoutTimer timer = new TimeoutTimer(response, AGILLA_RTS_TIMEOUT, timerid++); MessageJ rMsg = waitForResponse(); if (rMsg instanceof TimeoutMsgJ && ((TimeoutMsgJ) rMsg).id() == timer.id()) { log("doMonoOp: Remote TS operation timed out."); return null; } else if (rMsg instanceof AgillaTSResMsgJ) { AgillaTSResMsgJ results = (AgillaTSResMsgJ) rMsg; log("doMonoOp: Got results, " + (results.isSuccess() ? "SUCCESS" : "FAIL")); if (results.isSuccess()) return results.getTuple(); else return null; } return null; }
/** * Re-scans the bus for devices. <i>ScanForDevices()</i> is called automatically by <i>{@link * #open() open()}</i>. <i>You must terminate use of all USB devices before calling * scanForDevices()!</i> After calling <i>scanForDevices()</i> you can reestablish connections to * USB devices. * * @return This device manager, useful for chaining together multiple operations. * @throws OperationFailedException */ public USBDeviceManager scanForDevices() { if (isOpen()) { deviceList.clear(); final int MAX_DEVICES = 100; int devices[] = new int[1 + MAX_DEVICES * 2]; // device index-product ID pairs final int result = getDeviceByProductID(MIN_PRODUCT_ID, MAX_PRODUCT_ID, devices); // get all devices if (result != SUCCESS) throw new OperationFailedException(result); final int numDevices = devices[0]; for (int index = 0; index < numDevices; index++) { USBDevice device = null; final int deviceIndex = devices[1 + index * 2]; final int productID = devices[1 + index * 2 + 1]; if (USB_AI16_Family.isSupportedProductID(productID)) { device = new USB_AI16_Family(productID, deviceIndex); } else if (USB_AO16_Family.isSupportedProductID(productID)) { device = new USB_AO16_Family(productID, deviceIndex); } else if (USB_CTR_15_Family.isSupportedProductID(productID)) { device = new USB_CTR_15_Family(productID, deviceIndex); } else if (USB_DA12_8A_Family.isSupportedProductID(productID)) { device = new USB_DA12_8A_Family(productID, deviceIndex); } else if (USB_DA12_8E_Family.isSupportedProductID(productID)) { device = new USB_DA12_8E_Family(productID, deviceIndex); } else if (USB_DIO_16_Family.isSupportedProductID(productID)) { device = new USB_DIO_16_Family(productID, deviceIndex); } else if (USB_DIO_32_Family.isSupportedProductID(productID)) { device = new USB_DIO_32_Family(productID, deviceIndex); } else if (USB_DIO_Family.isSupportedProductID(productID)) { device = new USB_DIO_Family(productID, deviceIndex); } // else if( USB_DIO_Family.isSupportedProductID( ... if (device != null) deviceList.add(device); } // for( int index ... } else throw new OperationFailedException(MESSAGE_NOT_OPEN); return this; } // scanForDevices()
/** * "Closes" the USB device manager for use. When finished using the USB device manager, and * assuming <i>{@link #open() open()}</i> was properly called, <i>close()</i> must be called. * <i>Close()</i> terminates use of the underlying AIOUSB module and discards the list of devices * found. <i>You must terminate use of all USB devices before calling close()!</i> You can call * <i>open()</i> again to reinitialize things and reestablish connections to USB devices. * * @return This device manager, useful for chaining together multiple operations. * @throws OperationFailedException */ public USBDeviceManager close() { if (isOpen()) { deviceList.clear(); openStatus = 0; exit(); } else throw new OperationFailedException(MESSAGE_NOT_OPEN); return this; } // close()
/** Met à jour le cache en fonction de la liste todo */ private void updateCache() { aladin.trace(2, "Start cache updater..."); Vector v; synchronized (this) { v = (Vector) todo.clone(); todo.clear(); } Enumeration e = v.elements(); while (e.hasMoreElements()) { String url = (String) e.nextElement(); try { putInCache(url); } catch (Exception e1) { } Util.pause(1000); // Pose entre deux } fin(); }
/** Initializes the cpu. */ public void boot() { stackSegment.setStartAddress(Definitions.STACK_START_ADDRESS); workingStackSegment.setStartAddress(Definitions.STACK_START_ADDRESS); localSegment.setEnabledRange( Definitions.STACK_START_ADDRESS, Definitions.STACK_END_ADDRESS, true); argSegment.setEnabledRange( Definitions.STACK_START_ADDRESS, Definitions.STACK_END_ADDRESS, true); thisSegment.setEnabledRange(Definitions.HEAP_START_ADDRESS, Definitions.HEAP_END_ADDRESS, true); thatSegment.setEnabledRange( Definitions.HEAP_START_ADDRESS, Definitions.SCREEN_END_ADDRESS, true); staticSegment.setStartAddress(Definitions.VAR_START_ADDRESS); staticSegment.setEnabledRange( Definitions.VAR_START_ADDRESS, Definitions.VAR_END_ADDRESS - 1, true); setSP(Definitions.STACK_START_ADDRESS); stackFrames.clear(); if (builtInFunctionsRunner != null) { builtInFunctionsRunner.killAllRunningBuiltInFunctions(); } }
// Parse a method declaration. static String getMethod(SamTokenizer f) throws TokenizerException { try { // The return type for all methods must be int. myCheck(f, "int"); // methodName stores the name of the method. String methodName = f.getWord(); if (symMap.containsKey(methodName)) throw new TokenizerException("Error: Duplicate declaration of method " + methodName); String asmCode = methodName; // The name of the method <-> index of the symbol table of the method in the symTables vector symMap.put(methodName, symTables.size()); symTables.addElement(new LinkedHashMap<String, Integer>()); // Since there cannot be another method declaration inside of a, the symbol table we are // dealing with is // always the last element of the symTables vector. symTables.lastElement().put(methodName, 0); asmCode += ":\n"; myCheck(f, '('); if (!f.check(')')) { // No SaM code generated by getFormals getFormals(f); myCheck(f, ')'); } actMap.put(methodName, params.size()); for (int i = 1; i <= params.size(); ++i) { // Add all formals to the symbol tabel symTables.lastElement().put(params.elementAt(params.size() - i), -i); } asmCode += getBody(f); // Clear the params vector and set varCounter back to 2. params.clear(); varCounter = 2; return asmCode; } catch (Exception e) { System.out.println(e.getMessage()); throw new TokenizerException("Error: Invalid method declaration."); } }
public static void main(String[] args) throws Exception { /* // Graph in Figure 4.3, format: list of unweighted edges // This example shows another form of reading graph input 13 16 0 1 1 2 2 3 0 4 1 5 2 6 3 7 5 6 4 8 8 9 5 10 6 11 7 12 9 10 10 11 11 12 */ File f = new File("in_04.txt"); Scanner sc = new Scanner(f); V = sc.nextInt(); E = sc.nextInt(); AdjList.clear(); for (int i = 0; i < V; i++) { Vector<IntegerPair> Neighbor = new Vector<IntegerPair>(); AdjList.add(Neighbor); // add neighbor list to Adjacency List } for (int i = 0; i < E; i++) { a = sc.nextInt(); b = sc.nextInt(); AdjList.get(a).add(new IntegerPair(b, 0)); AdjList.get(b).add(new IntegerPair(a, 0)); } // as an example, we start from this source, see Figure 4.3 s = 5; // BFS routine // inside void main(String[] args) -- we do not use recursion, thus we do not need to create // separate function! Vector<Integer> dist = new Vector<Integer>(); dist.addAll(Collections.nCopies(V, 1000000000)); dist.set(s, 0); // start from source Queue<Integer> q = new LinkedList<Integer>(); q.offer(s); p.clear(); p.addAll( Collections.nCopies(V, -1)); // to store parent information (p must be a global variable!) int layer = -1; // for our output printing purpose Boolean isBipartite = true; while (!q.isEmpty()) { int u = q.poll(); // queue: layer by layer! if (dist.get(u) != layer) System.out.printf("\nLayer %d:", dist.get(u)); layer = dist.get(u); System.out.printf(", visit %d", u); Iterator it = AdjList.get(u).iterator(); while (it.hasNext()) { // for each neighbours of u IntegerPair v = (IntegerPair) it.next(); if (dist.get(v.first()) == 1000000000) { // if v not visited before dist.set(v.first(), dist.get(u) + 1); // then v is reachable from u q.offer(v.first()); // enqueue v for next steps p.set(v.first(), u); // parent of v is u } else if ((dist.get(v.first()) % 2) == (dist.get(u) % 2)) // same parity isBipartite = false; } } System.out.printf("\nShortest path: "); printpath(7); System.out.printf("\n"); System.out.printf("isBipartite? %d\n", isBipartite ? 1 : 0); }
@SuppressWarnings({"unchecked", "unchecked"}) public static void main(String[] args) { Vector<String> v = new Vector<String>(); DataInputStream inn; PrintStream out; Indexer w = new Indexer("myhash"); try { FileInputStream indexSource = new FileInputStream("foo.txt"); w.restore(indexSource); // w.disp(); } catch (IOException e) { System.out.println(e.toString()); } try { ServerSocket serv = new ServerSocket(4402); System.out.println(serv.getInetAddress()); System.out.println("server started"); while (true) { Socket client = serv.accept(); System.out.println("Just connected to " + client.getRemoteSocketAddress()); inn = new DataInputStream(client.getInputStream()); System.out.println("client IP : " + client.getInetAddress()); String ob = inn.readLine(); System.out.println("ob is " + ob); String[] h = ob.split(" "); for (String i : h) { v.addElement(i.toLowerCase()); } // Take care to use the right usage of the Index structure // hash - Dictionary Structure based on a Hashtable or HashMap from the Java collections // list - Dictionary Structure based on Linked List // myhash - Dictionary Structure based on a Hashtable implemented by the students // bst - Dictionary Structure based on a Binary Search Tree implemented by the students // avl - Dictionary Structure based on AVL Tree implemented by the students // System.out.println(perform); System.out.println("search request for : " + v.toString()); // w.disp(); ObjectIterator<vecnod> i = w.retrievePages(new ObjectIterator<String>(v)); Vector<vecnod> no_dup_vec = new Vector<vecnod>(); Vector<vecnod> dup_vec = new Vector<vecnod>(); int argcount = v.size(); v.clear(); if (i == null) { System.out.println("Search complete. 0 hits found."); return; } vecnod temp = new vecnod(); System.out.println("Search results:"); while (i.hasNext()) { temp = i.next(); String s = temp.url.toString(); int bc = 1; for (int j = 0; j < s.length(); j++) { if (s.charAt(j) == '/') bc++; } temp.freq = temp.freq * 100 * 1 / (bc - 2); // ressigning rank System.out.println("URL is: " + s + " Rank is: " + temp.freq); } } } catch (Exception e) { e.printStackTrace(); } }
public String Play(String input) { Vector<String> v = new Vector<String>(); String output = ""; Indexer w = new Indexer("myhash"); try { FileInputStream indexSource = new FileInputStream("foo.txt"); w.restore(indexSource); // w.disp(); } catch (IOException e) { System.out.println(e.toString()); } try { String ob = input; System.out.println("ob is " + ob); String[] h = ob.split(" "); for (String i : h) { v.addElement(i.toLowerCase()); } // Take care to use the right usage of the Index structure // hash - Dictionary Structure based on a Hashtable or HashMap from the Java collections // list - Dictionary Structure based on Linked List // myhash - Dictionary Structure based on a Hashtable implemented by the students // bst - Dictionary Structure based on a Binary Search Tree implemented by the students // avl - Dictionary Structure based on AVL Tree implemented by the students // System.out.println(perform); System.out.println("search request for : " + v.toString()); // w.disp(); ObjectIterator<vecnod> i = w.retrievePages(new ObjectIterator<String>(v)); Vector<vecnod> no_dup_vec = new Vector<vecnod>(); Vector<vecnod> dup_vec = new Vector<vecnod>(); int argcount = v.size(); v.clear(); if (i == null) { System.out.println("Search complete. 0 hits found."); return ""; } vecnod temp = new vecnod(); System.out.println("Search results:"); while (i.hasNext()) { temp = i.next(); String s = temp.url.toString(); int bc = 1; for (int j = 0; j < s.length(); j++) { if (s.charAt(j) == '/') bc++; } temp.freq = temp.freq * 100 * 1 / (bc - 2); // ressigning rank // System.out.println("URL is: "+s+" Rank is: "+temp.freq); output = output + s + "\n"; } } catch (Exception e) { e.printStackTrace(); } return output; }
public void clearEvents() { events.clear(); }
public static Vector<Double> trainNode( String filename, int outputRepresentation, String inputRepresentation, int filter, double learningRate, int epochs) { Vector<Double> node = null; // initialize node to null double error = 1; // initialize error double output = 0; // initialize output Vector<Double> trainError = new Vector<Double>(); double meansq = 0; String binTarget = ""; String binaryRep = ""; int target; openFile(filename); // open our file for training firstRead = true; int targetCounter = 0; while ((target = readFileIntoInputVector(inputRepresentation)) != -2) { // while we have not reached out end of file error if (outputRepresentation == 4) { binTarget = Integer.toBinaryString(target); // convert target to binary int[] targetArray = new int[4]; // array to hold binary ints for (int h = 0; h < targetArray.length; h++) { // add binary elements to int array try { targetArray[targetArray.length - h - 1] = Character.digit(binTarget.charAt(binTarget.length() - h - 1), 10); } catch (IndexOutOfBoundsException e) { // if there is empty spaces, fill with zeros targetArray[targetArray.length - h - 1] = 0; } } target = targetArray[filter]; binTarget = ""; for (int i = 0; i < targetArray.length; i++) { binTarget = binTarget + targetArray[i]; } } if ((filter == target && outputRepresentation == 10) || outputRepresentation != 10) { if (node == null) { node = new Vector<Double>(); for (int i = 0; i < inputs.size(); i++) { // for each input double randWeight = 1; // initialize random weight while (randWeight > 0.15) // while out random isn't less than 0.15 randWeight = random.nextDouble(); // get a new random double if (random.nextBoolean()) randWeight = randWeight * -1; // randomly set to negative node.addElement(new Double(randWeight)); // store random weight } } targetCounter++; // train for number of epochs for (int i = 0; i < epochs; i++) { // for each epoch double weightedSum = 0; // set/reset the weighted sum to 0 for (int j = 0; j < inputs.size(); j++) { weightedSum += (inputs.elementAt(j) * node.elementAt(j)); // calculate weighted sum } output = activation(weightedSum); // retrieve output if (outputRepresentation == 1 || outputRepresentation == 10) output = output * 10; else if (outputRepresentation == 4) { // each node must have a whole number if (output > 0.5) output = 1; else output = 0; } error = target - output; // calculate error if (i == epochs - 1) { if (outputRepresentation == 4) { if (filter == 0) { allOutputs.ensureCapacity(targetCounter); allOutputs.add(Integer.toString((int) output)); } else { allOutputs.set( targetCounter - 1, allOutputs.get(targetCounter - 1) + ((int) output)); } } trainError.add(error); if (Math.round(error) == 0 && outputRepresentation != 4) { trainCountCorrect++; } else if (outputRepresentation == 4 && filter == 3) { if (allOutputs.get(targetCounter - 1).equals(binTarget)) { trainCountCorrect++; } } } for (int k = 0; k < inputs.size(); k++) { // for each input double derivative = (1.64872 * Math.exp(weightedSum)) / (Math.pow(1.64872 + Math.exp(weightedSum), 2)); // calculate new weights double newWeight = node.elementAt(k) + (learningRate * inputs.elementAt(k) * error * derivative); // cont. node.setElementAt(newWeight, k); // update weights } } } inputs.clear(); } errorVect.addElement((Vector<Double>) trainError.clone()); trainError.clear(); if (outputRepresentation == 4 && filter == 3) System.out.println( "Training Percent: " + (100 * (double) trainCountCorrect / (double) targetCounter)); if (outputRepresentation == 10 && filter == 9) System.out.println( "Training Percent: " + (10 * (double) trainCountCorrect / (double) targetCounter)); if (outputRepresentation == 1) System.out.println( "Training Percent: " + (100 * (double) trainCountCorrect / (double) targetCounter)); closeFile(); return node; // node is now trained for an epoch }
public int processCmd(String cmd) throws TException, HiveException { SessionState ss = SessionState.get(); ss.setiscli(true); String cmd_trimmed = cmd.trim(); String[] tokens = cmd_trimmed.split("\\s+"); String cmd_1 = cmd_trimmed.substring(tokens[0].length()).trim(); int ret = 0; if (tokens[0].equalsIgnoreCase("delete")) { Vector<String> nexttoken = new Vector<String>(); nexttoken.add("jar"); nexttoken.add("file"); nexttoken.add("from"); if (tokens.length < 2 || !nexttoken.contains(tokens[1].toLowerCase())) { String errorMessage = "\nif delete resource:\n" + "Usage: delete [FILE|JAR] <value> [<value>]*\n" + "if delete table rows:\n" + "Usage: delete from tableName [where searchCondition]"; console.printError(errorMessage); ret = 1; return ret; } } if (tokens[0].equalsIgnoreCase("dfs") || tokens[0].equalsIgnoreCase("zktest")) { String errorMessage = "\ntdw hive do not support " + tokens[0].toLowerCase() + " operation\n"; throw new HiveException(errorMessage); } if (cmd_trimmed.toLowerCase().equals("quit") || cmd_trimmed.toLowerCase().equals("exit")) { System.exit(0); } else if (cmd_trimmed.startsWith("!")) { String shell_cmd = cmd_trimmed.substring(1); try { Process executor = Runtime.getRuntime().exec(shell_cmd); StreamPrinter outPrinter = new StreamPrinter(executor.getInputStream(), null, ss.out); StreamPrinter errPrinter = new StreamPrinter(executor.getErrorStream(), null, ss.err); outPrinter.start(); errPrinter.start(); ret = executor.waitFor(); if (ret != 0) { console.printError("Command failed with exit code = " + ret); } } catch (Exception e) { console.printError( "Exception raised from Shell command " + e.getLocalizedMessage(), org.apache.hadoop.util.StringUtils.stringifyException(e)); ret = 1; } } else if (tokens[0].toLowerCase().equals("list")) { SessionState.ResourceType t; if (tokens.length < 2 || (t = SessionState.find_resource_type(tokens[1])) == null) { console.printError( "Usage: list [" + StringUtils.join(SessionState.ResourceType.values(), "|") + "] [<value> [<value>]*]"); ret = 1; } else { List<String> filter = null; if (tokens.length >= 3) { System.arraycopy(tokens, 2, tokens, 0, tokens.length - 2); filter = Arrays.asList(tokens); } Set<String> s = ss.list_resource(t, filter); if (s != null && !s.isEmpty()) ss.out.println(StringUtils.join(s, "\n")); } } else { CommandProcessor proc = CommandProcessorFactory.get(tokens); if (proc != null) { if (proc instanceof Driver) { Driver qp = (Driver) proc; PrintStream out = ss.out; long start = System.currentTimeMillis(); try { ret = qp.run(cmd); } catch (Exception e1) { e1.printStackTrace(); } if (ret != 0) { qp.close(); return ret; } Vector<String> res = new Vector<String>(); try { while (qp.getResults(res)) { for (String r : res) { out.println(r); } res.clear(); if (out.checkError()) { break; } } } catch (IOException e) { console.printError( "Failed with exception " + e.getClass().getName() + ":" + e.getMessage(), "\n" + org.apache.hadoop.util.StringUtils.stringifyException(e)); ret = 1; } int cret = qp.close(); if (ret == 0) { ret = cret; } long end = System.currentTimeMillis(); if (end > start) { double timeTaken = (double) (end - start) / 1000.0; console.printInfo("Time taken: " + timeTaken + " seconds", null); } } else { try { ret = proc.run(cmd_1); } catch (Exception e) { e.printStackTrace(); } } } } return ret; }
private void parsePostScript() { try { BufferedReader PSIn = new BufferedReader(new FileReader("data/out/" + name + ".ps")); // parse header while (PSIn.ready()) { String S = PSIn.readLine().trim(); if (S.contains("EndSetup")) { break; } else { if (S.startsWith("/magfont")) { fontInfo.add(S); } else if (S.startsWith("/lily-output-units")) { outputUnits = Float.parseFloat(S.split(" ")[1]); for (String T : fontInfo) { addFont( T.split(" ")[0].substring(1), T.split(" ")[2].substring(1), (float) outputUnits * Float.parseFloat(T.split(" ")[3])); } } else if (S.startsWith("/output-scale")) { outputScale = Float.parseFloat(S.split(" ")[1]); } else if (S.startsWith("/staff-height")) { staffLineHeight = Float.parseFloat(S.split(" ")[1]) / 4; } } } scale = outputUnits * outputScale; for (int layer = 0; layer < staves; ++layer) { Vector<Vector<Double>> staff = new Vector<Vector<Double>>(); for (int page = 0; page < pages; ++page) { staff.add(new Vector<Double>()); } staffLines.add(staff); } Vector<Double> cStaffs = new Vector<Double>(); String prevLine = ""; int currPage = 1; // parse the rest of the file while (PSIn.ready()) { String S = PSIn.readLine().trim(); if (S.contains("noteheads") || S.contains("rests")) { // extract coordinate, glyph, and font information String T[] = S.split(" "); NotePanel N = new NotePanel(); N.setCoordinates(Double.parseDouble(T[0]), -Double.parseDouble(T[1])) .setGlyph(T[4].substring(1)) .setGonville(fonts.get(T[3])); if (S.contains("rests")) { T = S.substring(S.lastIndexOf("rests")).split("[. ]"); N.setRest(Integer.parseInt(T[1])); } T = prevLine.substring(prevLine.lastIndexOf(this.name + ".ly")).split(":"); N.setLine(Integer.parseInt(T[1]), Integer.parseInt(T[2])).setPage(currPage); if (N.lyLine < staffLine || staffLine == 0) { notes[0].add(N); } else { notes[1].add(N); } } else if (S.contains("accidentals")) { // String T[] = S.split(" "); // lastNote.setAccidentals(Double.parseDouble(T[0]), -Double.parseDouble(T[1]), // T[4].substring(1), T[3]); } else if (S.startsWith("%%Page:")) { currPage = Integer.parseInt(S.split(" ")[1]); } if (S.contains("draw_line")) { cStaffs.add(-Double.parseDouble(S.split(" ")[1])); if (cStaffs.size() >= 5 * staves) { // found a full staff Collections.sort(cStaffs); staffLines.get(0).get(currPage - 1).add(cStaffs.get(4) + staffLineHeight); if (staves > 1) { staffLines.get(1).get(currPage - 1).add(cStaffs.get(5) - staffLineHeight); } cStaffs.clear(); } } else if (!S.contains("draw_round_box")) { cStaffs.clear(); } if (S.contains(this.name + ".ly")) { prevLine = S; } } // sort the notes we found from the PS by where they occurred in the .ly for (int i = 0; i < staves; ++i) { Collections.sort(notes[i]); } // find tied notes for (int i = 0; i < staves; ++i) { int cTie = 0; int cNote = 0; while (cTie < ties.size() && cNote < notes[i].size() - 1) { ArrayList<Integer> tie = ties.get(cTie); NotePanel prevNote = notes[i].get(cNote); NotePanel nextNote = notes[i].get(cNote + 1); if (pairComp(tie.get(0), tie.get(1), prevNote.lyLine, prevNote.lyNumber) != -1 && pairComp(tie.get(0), tie.get(1), nextNote.lyLine, nextNote.lyNumber) != 1) { // tie is located between these notes nextNote.setTie(true); ++cNote; ++cTie; } else if (pairComp(tie.get(0), tie.get(1), prevNote.lyLine, prevNote.lyNumber) != -1) { ++cNote; } else { ++cTie; } } } PSIn.close(); } catch (Exception e) { System.err.println("Parsing the score from Lilypond's output has failed. Error: "); e.printStackTrace(); } }