private void swap(List y, List z, Random rdm) { int count = 0; for (int i = 0; i < y.size(); i++) { double p = rdm.nextDouble(); if (p < 0.5) { Object t = y.get(i); y.set(i, z.get(i)); z.set(i, t); count++; } } // end for i // logger.info("swapped " + count + " out of " + y.size()); } // end swap
public void reduce(IntWritable key, Iterable<Text> values, Context context) throws IOException, InterruptedException { List<Double> newCentroid = null; int numPoints = 0; for (Text value : values) { ++numPoints; List<Double> p = GetPoint(value.toString()); if (newCentroid == null) { // initialize the new centroid to the first element newCentroid = new ArrayList<Double>(p); } else { for (int i = 0; i < newCentroid.size(); i++) { newCentroid.set(i, newCentroid.get(i) + p.get(i)); } } } // now the newCentroid contains the sum of all the points // so to get the average of all the points, we need to // divide each entry by the total number of points for (int i = 0; i < newCentroid.size(); i++) { newCentroid.set(i, newCentroid.get(i) / (double) numPoints); } // now create a string containing all the new centroid's coordinates String s = null; for (Double d : newCentroid) { if (s == null) { s = d.toString(); } else { s += " " + d.toString(); } } newCentroids.add(s); if (newCentroids.size() == 10) { WriteNewCentroids(context); } // output the centroid ID and the centroid data context.write(key, new Text(s)); }
private void crossBorder() { if (isEnd) return; List<Block> blockTemp = new ArrayList<>(blocks); switch (inputDirection) { case 0: for (int i = 0; i < blockTemp.size(); i++) if (blockTemp.get(i).getY() >= 460) { Block temp = blockTemp.get(i); temp.setY(0); blockTemp.set(i, temp); } break; case 1: for (int i = 0; i < blockTemp.size(); i++) if (blockTemp.get(i).getX() >= 490) { Block temp = blockTemp.get(i); temp.setX(0); blockTemp.set(i, temp); } break; case 2: for (int i = 0; i < blockTemp.size(); i++) if (blockTemp.get(i).getY() <= 0) { Block temp = blockTemp.get(i); temp.setY(450); blockTemp.set(i, temp); } break; case 3: for (int i = 0; i < blockTemp.size(); i++) if (blockTemp.get(i).getX() <= 0) { Block temp = blockTemp.get(i); temp.setX(480); blockTemp.set(i, temp); } break; } Deque<Block> blocksTemp = new ArrayDeque<>(); for (int i = blockTemp.size() - 1; i >= 0; i--) blocksTemp.push(blockTemp.get(i)); blocks = blocksTemp; }
private synchronized void addRRset(Name name, RRset rrset) { if (!hasWild && name.isWild()) hasWild = true; Object types = data.get(name); if (types == null) { data.put(name, rrset); return; } int rtype = rrset.getType(); if (types instanceof List) { List list = (List) types; for (int i = 0; i < list.size(); i++) { RRset set = (RRset) list.get(i); if (set.getType() == rtype) { list.set(i, rrset); return; } } list.add(rrset); } else { RRset set = (RRset) types; if (set.getType() == rtype) data.put(name, rrset); else { LinkedList list = new LinkedList(); list.add(set); list.add(rrset); data.put(name, list); } } }
private ConditionalPermissionInfo setConditionalPermissionInfo( String name, ConditionInfo[] conds, PermissionInfo[] perms, boolean firstTry) { ConditionalPermissionUpdate update = newConditionalPermissionUpdate(); List rows = update.getConditionalPermissionInfos(); ConditionalPermissionInfo newInfo = newConditionalPermissionInfo(name, conds, perms, ConditionalPermissionInfo.ALLOW); int index = -1; if (name != null) { for (int i = 0; i < rows.size() && index < 0; i++) { ConditionalPermissionInfo info = (ConditionalPermissionInfo) rows.get(i); if (name.equals(info.getName())) { index = i; } } } if (index < 0) { // must always add to the beginning (bug 303930) rows.add(0, newInfo); index = 0; } else { rows.set(index, newInfo); } synchronized (lock) { if (!update.commit()) { if (firstTry) // try again setConditionalPermissionInfo(name, conds, perms, false); } return condAdminTable.getRow(index); } }
public static void loadDescriptors( String pluginsPath, List<IdeaPluginDescriptorImpl> result, @Nullable StartupProgress progress, int pluginsCount) { final File pluginsHome = new File(pluginsPath); final File[] files = pluginsHome.listFiles(); if (files != null) { int i = result.size(); for (File file : files) { final IdeaPluginDescriptorImpl descriptor = loadDescriptor(file, PLUGIN_XML); if (descriptor == null) continue; if (progress != null) { progress.showProgress( descriptor.getName(), PLUGINS_PROGRESS_MAX_VALUE * ((float) ++i / pluginsCount)); } int oldIndex = result.indexOf(descriptor); if (oldIndex >= 0) { final IdeaPluginDescriptorImpl oldDescriptor = result.get(oldIndex); if (StringUtil.compareVersionNumbers(oldDescriptor.getVersion(), descriptor.getVersion()) < 0) { result.set(oldIndex, descriptor); } } else { result.add(descriptor); } } } }
/** set throws an IndexOutOfBoundsException on a negative index */ public void testSet1_IndexOutOfBoundsException() { try { List c = emptyArray(); c.set(-1, "qwerty"); shouldThrow(); } catch (IndexOutOfBoundsException e) { } }
/** set throws an IndexOutOfBoundsException on a too high index */ public void testSet2() { try { List c = emptyArray(); c.add("asdasd"); c.add("asdad"); c.set(100, "qwerty"); shouldThrow(); } catch (IndexOutOfBoundsException e) { } }
private Character addEnumValue(T value, int position) { char ordinal = (char) position; if (ordinal != position) throw new IndexOutOfBoundsException( "Too many values in Enumerated16 field, try calling compact()"); map.put(value, ordinal); if (ordinal == list.size()) list.add(ordinal, value); else list.set(ordinal, value); return ordinal; }
/** * Set the given index with the given element, if the SQLJSON object is a JSON array. * * @param index * @param object * @return */ @Override public void set(int index, Object object) throws SQLException { if (!(jsonObject instanceof List)) { throw new SQLException("SQLJSON object is not a list"); } else { // this is a hack List backingList = ((ValueList) jsonObject).list(); //noinspection unchecked backingList.set(index, object); } }
// The Apriori Algorithm private static List<Itemset> apriori(List<Transaction> transactions, double minsup) { if (transactions.isEmpty()) { return null; } // Generate frequent 1-itemset List<Integer> occurancesOfItems = new ArrayList<>(); for (int i = 0; i != transactions.get(0).getNumOfTotalItems(); ++i) { occurancesOfItems.add(0); } for (Transaction transaction : transactions) { for (int index : transaction.items()) { occurancesOfItems.set(index, occurancesOfItems.get(index) + 1); } } int numOfTransactions = transactions.size(); List<Itemset> frequentOneItemsets = new ArrayList<>(); for (int i = 0; i != occurancesOfItems.size(); ++i) { if ((double) occurancesOfItems.get(i) / numOfTransactions >= minsup) { Itemset itemset = new Itemset(i); frequentOneItemsets.add(itemset); } } // A list of itemsets to store the frequent k-itemsets, k = 1, 2, ... List<List<Itemset>> listOfFrequentItemsets = new ArrayList<List<Itemset>>(); listOfFrequentItemsets.add( new ArrayList<Itemset>()); // case: k = 0, we fill it with an empty itemsets listOfFrequentItemsets.add(frequentOneItemsets); // case: k = 1 List<Itemset> prunedCandidates; List<Itemset> frequentItemsets; int k = 1; while ((frequentItemsets = listOfFrequentItemsets.get(k)) != null) { List<Itemset> newCandidates = generateCandidates(frequentItemsets); prunedCandidates = prune(newCandidates, frequentItemsets); List<Itemset> candidates = determineFrequentItemsets(prunedCandidates, transactions, minsup); listOfFrequentItemsets.add(candidates); k++; } // Union the frequent itemsets as result List<Itemset> result = new ArrayList<>(); for (List<Itemset> list : listOfFrequentItemsets) { if (list != null) { result.addAll(list); } } return result; }
protected void addOrReplace(ParsedMapping parsedMapping) { MappingKey key = new MappingKey(parsedMapping); for (int i = 0; i < mappings.size(); i++) { if (key.equals(new MappingKey(mappings.get(i)))) { logger.warn("{}\nis replaced with\n{}", mappings.get(i), parsedMapping); mappings.set(i, parsedMapping); return; } } logger.debug("Parsed {}", parsedMapping); mappings.add(parsedMapping); }
/** * backward pass 2: update impression features (1) \hat{mu}' (mu_hat_prime_s) (2) \hat{V}' * (v_hat_prime_s) */ public static void backward2(boolean update_grad) { double c = (1 - lambda) * (1 - lambda) / (sigma * sigma); for (int t1 = T - 1; t1 > t0; t1--) { int t = t1 - t0; // System.out.println("backward 2;\tt = " + t1); if (t != T - 1 - t0) { double[][] mu_prime_pre_t = mu_prime_s.get(t - 1); // \mu'^{t-1} [t-1] double[][] mu_hat_prime_t = mu_hat_prime_s.get(t); // \hat{\mu}'^{t} [t-1] double V_prime_pre_t = v_prime_s.get(t - 1); // V'^{t-1} double V_hat_prime_t = v_hat_prime_s.get(t); // \hat{V}'{t} /* calculate \hat{\mu}' at time t-1 */ double[][] mu_hat_prime_pre_t = new double[n][K]; double factor_1 = (sigma * sigma) / (V_prime_pre_t + sigma * sigma); double factor_2 = (V_prime_pre_t) / (V_prime_pre_t + sigma * sigma); for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { mu_hat_prime_pre_t[i][k] = factor_1 * mu_prime_pre_t[i][k] + factor_2 * mu_hat_prime_t[i][k]; } /* calculate \hat{V}' at time t-1 */ double v_hat_prime_pre_t = V_prime_pre_t + factor_2 * factor_2 * (V_hat_prime_t - V_prime_pre_t - sigma * sigma); /* update \mu and V */ mu_hat_prime_s.set(t - 1, mu_hat_prime_pre_t); v_hat_prime_s.set(t - 1, v_hat_prime_pre_t); /* calculate and update grad_mu_hat_prime at time t-1 */ if (update_grad) for (int s = 0; s < T - t0; s++) { double[][] grad_mu_prime_pre_t_s = grad_mu_prime_s.get((t - 1) * (T - t0) + s); double[][] grad_mu_hat_prime_t_s = grad_mu_hat_prime_s.get(t * (T - t0) + s); double[][] grad_mu_hat_prime_pre_t_s = new double[n][K]; for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { grad_mu_hat_prime_pre_t_s[i][k] = factor_1 * grad_mu_prime_pre_t_s[i][k] + factor_2 * grad_mu_hat_prime_t_s[i][k]; } grad_mu_hat_prime_s.set((t - 1) * (T - t0) + s, grad_mu_hat_prime_pre_t_s); } } else { /* * initial condition for backward pass: * (1) \hat{\mu}'^{T} = \mu'^{T} * (2) \hat{V}'^{T} = V'^{T} * (3) \hat{grad_mu}'^{T/s} = grad_mu'^{T/s}, \forall s */ mu_hat_prime_s.set(t, mu_prime_s.get(t)); v_hat_prime_s.set(t, v_prime_s.get(t)); if (update_grad) for (int s = 0; s < T - t0; s++) { grad_mu_hat_prime_s.set(t * (T - t0) + s, grad_mu_prime_s.get(t * (T - t0) + s)); } } /* end for each t */ } }
public void compactEnd() { final int compactSize = compactIndexUsed.cardinality(); if (compactSize == map.size()) { return; } for (int i = 1; i < list.size(); i++) { if (compactIndexUsed.get(i)) continue; // to be removed T t = list.get(i); list.set(i, null); map.remove(t); if (addPosition > i) addPosition = i; } }
/** * Load chromosomes from given ID or file name. * * @param idOrFile Genome ID or file name where chromosome lengths written * @return Chromosome lengths * @throws IOException if chromosome length file not found */ public static List<Chromosome> loadChromosomes(String idOrFile) throws IOException { InputStream is = null; try { // Note: to get this to work, had to edit Intellij settings // so that "?*.sizes" are considered sources to be copied to class path is = HiCTools.class.getResourceAsStream(idOrFile + ".chrom.sizes"); if (is == null) { // Not an ID, see if its a file File file = new File(idOrFile); if (file.exists()) { is = new FileInputStream(file); } else { throw new FileNotFoundException("Could not find chromosome sizes file for: " + idOrFile); } } List<Chromosome> chromosomes = new ArrayList(); chromosomes.add(0, null); // Index 0 reserved for "whole genome" psuedo-chromosome Pattern pattern = Pattern.compile("\t"); BufferedReader reader = new BufferedReader(new InputStreamReader(is)); String nextLine; long genomeLength = 0; int idx = 1; while ((nextLine = reader.readLine()) != null) { String[] tokens = pattern.split(nextLine); if (tokens.length == 2) { String name = tokens[0]; int length = Integer.parseInt(tokens[1]); genomeLength += length; chromosomes.add(idx, new Chromosome(idx, name, length)); idx++; } else { System.out.println("Skipping " + nextLine); } } // Add the "psuedo-chromosome" All, representing the whole genome. Units are in kilo-bases chromosomes.set(0, new Chromosome(0, "All", (int) (genomeLength / 1000))); return chromosomes; } finally { if (is != null) is.close(); } }
public void updateBean(AlbumBean newBean, AlbumBean oldBean) throws LibraryException { synchronized (libraryList) { // Find the bean int index = libraryList.indexOf(oldBean); if (index == -1) { LibraryException le = new LibraryException(Utils.getResourceString(ERROR_BEAN_NOT_FOUND)); throw le; } // Set the new bean libraryList.set(index, newBean); setChanged(); fireLibraryChangeEvent( new LibraryChangeEvent(this, new AlbumBean[] {oldBean}, LibraryChangeEvent.UPDATE)); } }
/** sublists contains elements at indexes offset from their base */ public void testSubList() { List a = populatedArray(10); assertTrue(a.subList(1, 1).isEmpty()); for (int j = 0; j < 9; ++j) { for (int i = j; i < 10; ++i) { List b = a.subList(j, i); for (int k = j; k < i; ++k) { assertEquals(new Integer(k), b.get(k - j)); } } } List s = a.subList(2, 5); assertEquals(3, s.size()); s.set(2, m1); assertEquals(a.get(4), m1); s.clear(); assertEquals(7, a.size()); }
@Override protected void filterForLanguage(List<String> suggestions) { if (language.getShortNameWithCountryAndVariant().equals("de-CH")) { for (int i = 0; i < suggestions.size(); i++) { String s = suggestions.get(i); suggestions.set(i, s.replace("ß", "ss")); } } // This is not quite correct as it might remove valid suggestions that start with "-", // but without this we get too many strange suggestions that start with "-" for no apparent // reason // (e.g. for "Gratifikationskrisem" -> "-Gratifikationskrisen"): Iterator<String> iterator = suggestions.iterator(); while (iterator.hasNext()) { String suggestion = iterator.next(); if (suggestion.length() > 1 && suggestion.startsWith("-")) { iterator.remove(); } } }
private static int readTokensFile( String tokensFile, List<String> tokenName, List<Integer> tokenType, List<String> nameOf) throws Exception { String line, name; String[] part; int nTokens = 0; int type, i; BufferedReader in = new BufferedReader(new FileReader(tokensFile)); while ((line = in.readLine()) != null) { part = line.split("="); name = part[0]; type = Integer.parseInt(part[1]); tokenName.add(name); tokenType.add(type); while (nameOf.size() <= type) { nameOf.add("NONE"); } nameOf.set(type, name); nTokens++; } in.close(); return nTokens; }
public static void main(String args[]) throws FileNotFoundException, IOException { System.out.println("Gathering data..."); // Use char[] for ease in building strings, despite only using 8 bits. int numElements = 65536; char[] info = new char[numElements]; for (int i = 0; i < info.length; i++) { if (i == '\n' || i == '\r') info[i] = NEWLINE_CODE; else if (i == ' ' || i == '\t' || i == '\f') info[i] = SPACE_CODE; else if (i < 128 && Character.isLowerCase((char) i)) info[i] = LOWER_CODE; // Ascii lower case else if (i < 128 && Character.isUpperCase((char) i)) info[i] = UPPER_CODE; // Ascii upper case else if (i < 128 && Character.isDigit((char) i)) info[i] = DIGIT_CODE; // Ascii digit else if (Character.isJavaIdentifierStart((char) i)) info[i] = OTHER_LETTER_CODE; else if (Character.isJavaIdentifierPart((char) i)) info[i] = OTHER_DIGIT_CODE; else { info[i] = BAD_CODE; numElements--; } } System.out.println("Compressing tables..."); int bestShift = 0; int bestEst = info.length; String bestBlkStr = null; for (int i = 3; i < 11; i++) { int blkSize = 1 << i; Map blocks = new HashMap(); List blkArray = new ArrayList(); System.out.print("shift: " + i); for (int j = 0; j < info.length; j += blkSize) { String key = new String(info, j, blkSize); if (blocks.get(key) == null) { blkArray.add(key); blocks.put(key, new Integer(blkArray.size())); } } int blkNum = blkArray.size(); int blockLen = blkNum * blkSize; System.out.print(" before " + blockLen); // // Try to pack blkArray, by finding successively smaller matches // between heads and tails of blocks. // for (int j = blkSize - 1; j > 0; j--) { Map tails = new HashMap(); for (int k = 0; k < blkArray.size(); k++) { String str = (String) blkArray.get(k); if (str == null) continue; String tail = str.substring(str.length() - j); List l = (List) tails.get(tail); if (l == null) tails.put(tail, new LinkedList(Collections.singleton(new Integer(k)))); else l.add(new Integer(k)); } // // Now calculate the heads, and merge overlapping blocks // block: for (int k = 0; k < blkArray.size(); k++) { String tomerge = (String) blkArray.get(k); if (tomerge == null) continue; while (true) { String head = tomerge.substring(0, j); LinkedList entry = (LinkedList) tails.get(head); if (entry == null) continue block; Integer other = (Integer) entry.removeFirst(); if (other.intValue() == k) { if (entry.size() > 0) { entry.add(other); other = (Integer) entry.removeFirst(); } else { entry.add(other); continue block; } } if (entry.size() == 0) tails.remove(head); // // A match was found. // String merge = blkArray.get(other.intValue()) + tomerge.substring(j); blockLen -= j; blkNum--; if (other.intValue() < k) { blkArray.set(k, null); blkArray.set(other.intValue(), merge); String tail = merge.substring(merge.length() - j); List l = (List) tails.get(tail); Collections.replaceAll(l, new Integer(k), other); continue block; } blkArray.set(k, merge); blkArray.set(other.intValue(), null); tomerge = merge; } } } StringBuffer blockStr = new StringBuffer(blockLen); for (int k = 0; k < blkArray.size(); k++) { String str = (String) blkArray.get(k); if (str != null) blockStr.append(str); } if (blockStr.length() != blockLen) throw new Error("Unexpected blockLen " + blockLen); int estimate = blockLen + (info.length >> (i - 1)); System.out.println(" after merge " + blockLen + ": " + estimate + " bytes"); if (estimate < bestEst) { bestEst = estimate; bestShift = i; bestBlkStr = blockStr.toString(); } } int blkSize = 1 << bestShift; char[] blocks = new char[info.length / blkSize]; for (int j = 0; j < info.length; j += blkSize) { String key = new String(info, j, blkSize); int index = bestBlkStr.indexOf(key); if (index == -1) throw new Error("Unexpected index for " + j); blocks[j >> bestShift] = (char) (index - j); } // // Process the code.h file // System.out.println("Generating code.h with shift of " + bestShift); PrintStream hfile = new PrintStream(new FileOutputStream("code.h")); printHeader(hfile, new String[] {"\"platform.h\""}); hfile.println("#ifndef code_INCLUDED"); hfile.println("#define code_INCLUDED"); hfile.println(); hfile.println("class Code"); hfile.println("{"); hfile.println(" //"); hfile.println(" // To facilitate the scanning, the character set is partitioned into"); hfile.println(" // 8 categories using the array CODE. These are described below"); hfile.println(" // together with some self-explanatory functions defined on CODE."); hfile.println(" //"); hfile.println(" enum {"); hfile.println(" SHIFT = " + bestShift + ","); hfile.println(" NEWLINE_CODE = " + NEWLINE_CODE + ','); hfile.println(" SPACE_CODE = " + SPACE_CODE + ','); hfile.println(" BAD_CODE = " + BAD_CODE + ','); hfile.println(" DIGIT_CODE = " + DIGIT_CODE + ','); hfile.println(" OTHER_DIGIT_CODE = " + OTHER_DIGIT_CODE + ','); hfile.println(" LOWER_CODE = " + LOWER_CODE + ','); hfile.println(" UPPER_CODE = " + UPPER_CODE + ','); hfile.println(" OTHER_LETTER_CODE = " + OTHER_LETTER_CODE); hfile.println(" };"); hfile.println(); hfile.println(" static char codes[" + bestBlkStr.length() + "];"); hfile.println(" static u2 blocks[" + blocks.length + "];"); hfile.println(); hfile.println(); hfile.println("public:"); hfile.println(); hfile.println(" static inline void SetBadCode(wchar_t c)"); hfile.println(" {"); hfile.println(" codes[(u2) (blocks[c >> SHIFT] + c)] = BAD_CODE;"); hfile.println(" }"); hfile.println(); hfile.println(" static inline void CodeCheck(wchar_t c)"); hfile.println(" {"); hfile.println(" assert((u2) (blocks[c >> SHIFT] + c) < " + bestBlkStr.length() + ");"); hfile.println(" }"); hfile.println(); hfile.println(" static inline bool CodeCheck(void)"); hfile.println(" {"); hfile.println(" for (int i = 0; i <= 0xffff; i++)"); hfile.println(" CodeCheck((wchar_t) i);"); hfile.println(" return true;"); hfile.println(" }"); hfile.println(); hfile.println(" //"); hfile.println(" // \\r characters are replaced by \\x0a in Stream::ProcessInput()."); hfile.println(" //"); hfile.println(" static inline bool IsNewline(wchar_t c)"); hfile.println(" {"); hfile.println(" return c == '\\x0a';"); hfile.println(" }"); hfile.println(); hfile.println(" static inline bool IsSpaceButNotNewline(wchar_t c)"); hfile.println(" {"); hfile.println(" return codes[(u2) (blocks[c >> SHIFT] + c)] == SPACE_CODE;"); hfile.println(" }"); hfile.println(); hfile.println(" static inline bool IsSpace(wchar_t c)"); hfile.println(" {"); hfile.println(" return codes[(u2) (blocks[c >> SHIFT] + c)] <= SPACE_CODE;"); hfile.println(" }"); hfile.println(); hfile.println(" static inline bool IsDigit(wchar_t c)"); hfile.println(" {"); hfile.println(" return codes[(u2) (blocks[c >> SHIFT] + c)] == DIGIT_CODE;"); hfile.println(" }"); hfile.println(); hfile.println(" static inline bool IsOctalDigit(wchar_t c)"); hfile.println(" {"); hfile.println(" return c >= U_0 && c <= U_7;"); hfile.println(" }"); hfile.println(); hfile.println(" static inline bool IsHexDigit(wchar_t c)"); hfile.println(" {"); hfile.println(" return c <= U_f && (c >= U_a ||"); hfile.println(" (c >= U_A && c <= U_F) ||"); hfile.println(" (c >= U_0 && c <= U_9));"); hfile.println(" }"); hfile.println(); hfile.println(" static inline bool IsUpper(wchar_t c)"); hfile.println(" {"); hfile.println(" return codes[(u2) (blocks[c >> SHIFT] + c)] == UPPER_CODE;"); hfile.println(" }"); hfile.println(); hfile.println(" static inline bool IsLower(wchar_t c)"); hfile.println(" {"); hfile.println(" return codes[(u2) (blocks[c >> SHIFT] + c)] == LOWER_CODE;"); hfile.println(" }"); hfile.println(); hfile.println(" static inline bool IsAlpha(wchar_t c)"); hfile.println(" {"); hfile.println(" return codes[(u2) (blocks[c >> SHIFT] + c)] >= LOWER_CODE;"); hfile.println(" }"); hfile.println(); hfile.println(" static inline bool IsAlnum(wchar_t c)"); hfile.println(" {"); hfile.println(" return codes[(u2) (blocks[c >> SHIFT] + c)] >= DIGIT_CODE;"); hfile.println(" }"); hfile.println(); hfile.println("};"); hfile.println(); hfile.println("#endif // code_INCLUDED"); printFooter(hfile); hfile.close(); // // Process the code.cpp file // System.out.println("Generating code.cpp"); PrintStream cfile = new PrintStream(new FileOutputStream("code.cpp")); printHeader(cfile, new String[] {"\"code.h\""}); cfile.println("char Code::codes[" + bestBlkStr.length() + "] ="); cfile.println("{"); for (int j = 0; j < bestBlkStr.length(); j += 4) { for (int k = 0; k < 4; k++) { if (k + j >= bestBlkStr.length()) break; if (k == 0) cfile.print(" "); cfile.print(" " + CODE_NAMES[bestBlkStr.charAt(k + j)] + ","); } cfile.println(); } cfile.println("};"); cfile.println(); cfile.println(); cfile.println("//"); cfile.println("// The Blocks vector:"); cfile.println("//"); cfile.println("u2 Code::blocks[" + blocks.length + "] ="); cfile.println("{"); for (int k = 0; k < blocks.length; k += 9) { for (int i = 0; i < 9; i++) { if (k + i >= blocks.length) break; if (i == 0) cfile.print(" "); cfile.print(" 0x" + Integer.toHexString(blocks[k + i]) + ","); } cfile.println(); } cfile.println("};"); printFooter(cfile); cfile.close(); // // Print statistics. // System.out.println( "Total static storage utilization is " + blocks.length * 2 + " bytes for block lookup"); System.out.println(" plus " + bestBlkStr.length() + " bytes for the encodings"); System.out.println( "The number of unicode characters legal in Java sourcecode is " + numElements); }
public static void main(String[] argv) throws IOException, CmdLineParser.UnknownOptionException, CmdLineParser.IllegalOptionValueException { if (argv.length < 4) { System.out.println("Usage: hictools pre <options> <inputFile> <outputFile> <genomeID>"); System.out.println(" <options>: -d only calculate intra chromosome (diagonal) [false]"); System.out.println( " : -o calculate densities (observed/expected), write to file [false]"); System.out.println(" : -t <int> only write cells with count above threshold t [0]"); System.out.println( " : -c <chromosome ID> only calculate map on specific chromosome"); System.exit(0); } Globals.setHeadless(true); CommandLineParser parser = new CommandLineParser(); parser.parse(argv); String[] args = parser.getRemainingArgs(); if (args[0].equals("sort")) { AlignmentsSorter.sort(args[1], args[2], null); } else if (args[0].equals("pairsToBin")) { String ifile = args[1]; String ofile = args[2]; String genomeId = args[3]; List<Chromosome> chromosomes = loadChromosomes(genomeId); AsciiToBinConverter.convert(ifile, ofile, chromosomes); } else if (args[0].equals("binToPairs")) { String ifile = args[1]; String ofile = args[2]; AsciiToBinConverter.convertBack(ifile, ofile); } else if (args[0].equals("printmatrix")) { if (args.length < 5) { System.err.println( "Usage: hictools printmatrix <observed/oe/pearson> hicFile chr1 chr2 binsize"); System.exit(-1); } String type = args[1]; String file = args[2]; String chr1 = args[3]; String chr2 = args[4]; String binSizeSt = args[5]; int binSize = 0; try { binSize = Integer.parseInt(binSizeSt); } catch (NumberFormatException e) { System.err.println("Integer expected. Found: " + binSizeSt); System.exit(-1); } dumpMatrix(file, chr1, chr2, binSize, type); } else if (args[0].equals("eigenvector")) { if (args.length < 4) { System.err.println("Usage: hictools eigenvector hicFile chr binsize"); } String file = args[1]; String chr = args[2]; String binSizeSt = args[3]; int binSize = 0; try { binSize = Integer.parseInt(binSizeSt); } catch (NumberFormatException e) { System.err.println("Integer expected. Found: " + binSizeSt); System.exit(-1); } calculateEigenvector(file, chr, binSize); } else if (args[0].equals("pre")) { String genomeId = ""; try { genomeId = args[3]; } catch (ArrayIndexOutOfBoundsException e) { System.err.println("No genome ID given"); System.exit(0); } List<Chromosome> chromosomes = loadChromosomes(genomeId); long genomeLength = 0; for (Chromosome c : chromosomes) { if (c != null) genomeLength += c.getSize(); } chromosomes.set(0, new Chromosome(0, "All", (int) (genomeLength / 1000))); String[] tokens = args[1].split(","); List<String> files = new ArrayList<String>(tokens.length); for (String f : tokens) { files.add(f); } Preprocessor preprocessor = new Preprocessor(new File(args[2]), chromosomes); preprocessor.setIncludedChromosomes(parser.getChromosomeOption()); preprocessor.setCountThreshold(parser.getCountThresholdOption()); preprocessor.setNumberOfThreads(parser.getThreadedOption()); preprocessor.setDiagonalsOnly(parser.getDiagonalsOption()); preprocessor.setLoadDensities(parser.getDensitiesOption()); preprocessor.preprocess(files); } }
/** * forward pass 1: update intrinsic features (1) mu (mu_s) (2) grad_mu (grad_mu_s) (3) variance V * (v_s) */ public static void forward1(boolean update_grad, int iter) { /* if (iter == 4) { int t = 15; double[][] h_t = new double[n][K]; double[][] h_hat_t = new double[n][K]; double[][] h_prime_t = new double[n][K]; double[][] h_hat_prime_t = new double[n][K]; for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { h_t[i][k] = h_s.get(t-1)[i][k]; h_hat_t[i][k] = h_hat_s.get(t-1)[i][k]; h_prime_t[i][k] = h_prime_s.get(t-1)[i][k]; h_hat_prime_t[i][k] = h_hat_prime_s.get(t-1)[i][k]; } h_s.set(t, h_t); h_hat_s.set(t, h_hat_t); h_prime_s.set(t, h_prime_t); h_hat_prime_s.set(t, h_hat_prime_t); } */ for (int t = 0; t < T - t0; t++) { // System.out.println("forward 1;\tt = " + t1); if (t != 0) { double delta_t = delta_s.get(t); // delta_t double[][] h_hat_t = h_hat_s.get(t); // \hat{h}^t [t] double[][] mu_pre_t = mu_s.get(t - 1); // mu^{t-1} (N*1) double V_pre_t = v_s.get(t - 1); // V^{t-1} Matrix a = new Matrix(AS.get(t - 1)); // A^{t-1} Matrix hprime_pre_t = new Matrix(h_prime_s.get(t - 1)); // h'^{t-1} Matrix ave_neighbors = a.times(hprime_pre_t); /* calculate \mu */ double[][] mu_t = new double[n][K]; double factor_1 = (delta_t * delta_t) / (delta_t * delta_t + sigma * sigma + (1 - lambda) * (1 - lambda) * V_pre_t); double factor_2 = (sigma * sigma + (1 - lambda) * (1 - lambda) * V_pre_t) / (delta_t * delta_t + sigma * sigma + (1 - lambda) * (1 - lambda) * V_pre_t); for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { mu_t[i][k] = factor_1 * ((1 - lambda) * mu_pre_t[i][k] + lambda * ave_neighbors.get(i, k)) + factor_2 * h_hat_t[i][k]; } /* calculate V */ double V_t = factor_2 * delta_t * delta_t; /* update \mu and V */ mu_s.set(t, mu_t); v_s.set(t, V_t); /* calculate and update grad_mu */ if (update_grad) for (int s = 0; s < T - t0; s++) { double[][] grad_pre_t_s = grad_mu_s.get((t - 1) * (T - t0) + s); double[][] grad_t_s = new double[n][K]; for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { grad_t_s[i][k] = factor_1 * (1 - lambda) * grad_pre_t_s[i][k]; if (t == s) { grad_t_s[i][k] += factor_2; } } grad_mu_s.set(t * (T - t0) + s, grad_t_s); } } else { /* mu, V: random init (keep unchanged) */ /* grad_mu: set to 0 (keep unchanged) */ } // Scanner sc = new Scanner(System.in); // int gu; gu = sc.nextInt(); /* end for each t */ } }
/** * Performs flush. * * @throws GridException If failed. */ private void doFlush() throws GridException { lastFlushTime = U.currentTimeMillis(); List<GridFuture> activeFuts0 = null; int doneCnt = 0; for (GridFuture<?> f : activeFuts) { if (!f.isDone()) { if (activeFuts0 == null) activeFuts0 = new ArrayList<>((int) (activeFuts.size() * 1.2)); activeFuts0.add(f); } else { f.get(); doneCnt++; } } if (activeFuts0 == null || activeFuts0.isEmpty()) return; while (true) { Queue<GridFuture<?>> q = null; for (Buffer buf : bufMappings.values()) { GridFuture<?> flushFut = buf.flush(); if (flushFut != null) { if (q == null) q = new ArrayDeque<>(bufMappings.size() * 2); q.add(flushFut); } } if (q != null) { assert !q.isEmpty(); boolean err = false; for (GridFuture fut = q.poll(); fut != null; fut = q.poll()) { try { fut.get(); } catch (GridException e) { if (log.isDebugEnabled()) log.debug("Failed to flush buffer: " + e); err = true; } } if (err) // Remaps needed - flush buffers. continue; } doneCnt = 0; for (int i = 0; i < activeFuts0.size(); i++) { GridFuture f = activeFuts0.get(i); if (f == null) doneCnt++; else if (f.isDone()) { f.get(); doneCnt++; activeFuts0.set(i, null); } else break; } if (doneCnt == activeFuts0.size()) return; } }
/** * Compile with avr-gcc. * * @param sketch Sketch object to be compiled. * @param buildPath Where the temporary files live and will be built from. * @param primaryClassName the name of the combined sketch file w/ extension * @return true if successful. * @throws RunnerException Only if there's a problem. Only then. * * [ROBOTIS]Changed prototype to support ARM Cortex-M3 based CM-900 Pandora project * 2012-09-26 [email protected] * */ public boolean compile(Sketch sketch, //change return type[ROBOTIS] String buildPath, String primaryClassName, boolean verbose, List<String> ignored) throws RunnerException { this.sketch = sketch; this.buildPath = buildPath; this.primaryClassName = primaryClassName; //예를 들면 cpp파일로 변환된 AnalogReadSerial.cpp this.verbose = verbose; this.sketchIsCompiled = false; System.out.println("Compiler.compile() sketch ="+sketch.getName()+"buildpath ="+buildPath+"primaryClassName ="+primaryClassName); // the pms object isn't used for anything but storage MessageStream pms = new MessageStream(this); String avrBasePath = Base.getAvrBasePath(); System.out.println("[ROBOTIS]avrBasePath ="+avrBasePath); Map<String, String> boardPreferences = Base.getBoardPreferences(); String core = boardPreferences.get("build.core"); System.out.println("[ROBOTIS]build.core ="+core); if (core == null) { RunnerException re = new RunnerException(_("No board selected; please choose a board from the Tools > Board menu.")); re.hideStackTrace(); throw re; } String corePath; if (core.indexOf(':') == -1) { Target t = Base.getTarget(); File coreFolder = new File(new File(t.getFolder(), "cores"), core); corePath = coreFolder.getAbsolutePath(); } else { Target t = Base.targetsTable.get(core.substring(0, core.indexOf(':'))); File coreFolder = new File(t.getFolder(), "cores"); coreFolder = new File(coreFolder, core.substring(core.indexOf(':') + 1)); corePath = coreFolder.getAbsolutePath(); } System.out.println("[ROBOTIS]corePath ="+corePath); String variant = boardPreferences.get("build.variant"); String variantPath = null; if (variant != null) { if (variant.indexOf(':') == -1) { Target t = Base.getTarget(); File variantFolder = new File(new File(t.getFolder(), "variants"), variant); variantPath = variantFolder.getAbsolutePath(); } else { Target t = Base.targetsTable.get(variant.substring(0, variant.indexOf(':'))); File variantFolder = new File(t.getFolder(), "variants"); variantFolder = new File(variantFolder, variant.substring(variant.indexOf(':') + 1)); variantPath = variantFolder.getAbsolutePath(); } } List<File> objectFiles = new ArrayList<File>(); // 0. include paths for core + all libraries sketch.setCompilingProgress(20); List includePaths = new ArrayList(); includePaths.add(corePath); if (variantPath != null) includePaths.add(variantPath); for (File file : sketch.getImportedLibraries()) { includePaths.add(file.getPath()); } // 1. compile the sketch (already in the buildPath) sketch.setCompilingProgress(30); objectFiles.addAll( compileFiles(avrBasePath, buildPath, includePaths, findFilesInPath(buildPath, "S", false), findFilesInPath(buildPath, "c", false), findFilesInPath(buildPath, "cpp", false), boardPreferences)); sketchIsCompiled = true; // 2. compile the libraries, outputting .o files to: <buildPath>/<library>/ sketch.setCompilingProgress(40); for (File libraryFolder : sketch.getImportedLibraries()) { File outputFolder = new File(buildPath, libraryFolder.getName()); File utilityFolder = new File(libraryFolder, "utility"); createFolder(outputFolder); // this library can use includes in its utility/ folder includePaths.add(utilityFolder.getAbsolutePath()); objectFiles.addAll( compileFiles(avrBasePath, outputFolder.getAbsolutePath(), includePaths, findFilesInFolder(libraryFolder, "S", false), findFilesInFolder(libraryFolder, "c", false), findFilesInFolder(libraryFolder, "cpp", false), boardPreferences)); outputFolder = new File(outputFolder, "utility"); createFolder(outputFolder); objectFiles.addAll( compileFiles(avrBasePath, outputFolder.getAbsolutePath(), includePaths, findFilesInFolder(utilityFolder, "S", false), findFilesInFolder(utilityFolder, "c", false), findFilesInFolder(utilityFolder, "cpp", false), boardPreferences)); // other libraries should not see this library's utility/ folder includePaths.remove(includePaths.size() - 1); } // 3. compile the core, outputting .o files to <buildPath> and then // collecting them into the core.a library file. sketch.setCompilingProgress(50); includePaths.clear(); includePaths.add(corePath); // include path for core only if (variantPath != null) includePaths.add(variantPath); List<File> coreObjectFiles = compileFiles(avrBasePath, buildPath, includePaths, findFilesInPath(corePath, "S", true), findFilesInPath(corePath, "c", true), findFilesInPath(corePath, "cpp", true), boardPreferences); String runtimeLibraryName = buildPath + File.separator + "core.a"; List baseCommandAR = new ArrayList(Arrays.asList(new String[] { avrBasePath + "avr-ar", "rcs", runtimeLibraryName })); for(File file : coreObjectFiles) { List commandAR = new ArrayList(baseCommandAR); commandAR.add(file.getAbsolutePath()); execAsynchronously(commandAR); } // 4. link it all together into the .elf file // For atmega2560, need --relax linker option to link larger // programs correctly. String optRelax = ""; String atmega2560 = new String ("atmega2560"); if ( atmega2560.equals(boardPreferences.get("build.mcu")) ) { optRelax = new String(",--relax"); } sketch.setCompilingProgress(60); List baseCommandLinker = new ArrayList(Arrays.asList(new String[] { avrBasePath + "avr-gcc", "-Os", "-Wl,--gc-sections"+optRelax, "-mmcu=" + boardPreferences.get("build.mcu"), "-o", buildPath + File.separator + primaryClassName + ".elf" })); for (File file : objectFiles) { baseCommandLinker.add(file.getAbsolutePath()); } baseCommandLinker.add(runtimeLibraryName); baseCommandLinker.add("-L" + buildPath); baseCommandLinker.add("-lm"); execAsynchronously(baseCommandLinker); List baseCommandObjcopy = new ArrayList(Arrays.asList(new String[] { avrBasePath + "avr-objcopy", "-O", "-R", })); List commandObjcopy; // 5. extract EEPROM data (from EEMEM directive) to .eep file. sketch.setCompilingProgress(70); commandObjcopy = new ArrayList(baseCommandObjcopy); commandObjcopy.add(2, "ihex"); commandObjcopy.set(3, "-j"); commandObjcopy.add(".eeprom"); commandObjcopy.add("--set-section-flags=.eeprom=alloc,load"); commandObjcopy.add("--no-change-warnings"); commandObjcopy.add("--change-section-lma"); commandObjcopy.add(".eeprom=0"); commandObjcopy.add(buildPath + File.separator + primaryClassName + ".elf"); commandObjcopy.add(buildPath + File.separator + primaryClassName + ".eep"); execAsynchronously(commandObjcopy); // 6. build the .hex file sketch.setCompilingProgress(80); commandObjcopy = new ArrayList(baseCommandObjcopy); commandObjcopy.add(2, "ihex"); commandObjcopy.add(".eeprom"); // remove eeprom data commandObjcopy.add(buildPath + File.separator + primaryClassName + ".elf"); commandObjcopy.add(buildPath + File.separator + primaryClassName + ".hex"); execAsynchronously(commandObjcopy); sketch.setCompilingProgress(90); return true; }
public static void test1(String seed) { /* read, init data & parameters */ for (int t = t0; t < T; t++) { // String fileDir = "../../data/graph/" + Integer.toString(t) + ".csv"; // original // co-voting dataset // String fileDir = "./data/" + Integer.toString(t) + ".csv"; // artificial toy dataset String fileDir = "../../data_sm/nips_17/out/" + seed + "/" + Integer.toString(t) + ".train.csv"; // nips dataset (smaller) Map<Integer, Double> freq = FileParser.readCSVDict(fileDir); double[][] G = new double[n][n]; double[][] A = new double[n][n]; double[][] mu = new double[n][K]; double[][] mu_hat = new double[n][K]; double[][] mu_prime = new double[n][K]; double[][] mu_hat_prime = new double[n][K]; double[][] h = new double[n][K]; double[][] h_hat = new double[n][K]; FileParser.readCSVGraph(fileDir, freq, G, A); for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { mu[i][k] = scale_0 * (rand.nextDouble() - 0.5); mu_hat[i][k] = scale_0 * (rand.nextDouble() - 0.5); mu_prime[i][k] = mu[i][k]; mu_hat_prime[i][k] = mu_hat[i][k]; h[i][k] = scale * (rand.nextDouble() - 0.5); h_hat[i][k] = scale * (rand.nextDouble() - 0.5); } GS.add(G); AS.add(A); mu_s.add(mu); mu_hat_s.add(mu_hat); mu_prime_s.add(mu_prime); mu_hat_prime_s.add(mu_hat_prime); h_s.add(h); h_prime_s.add(h); h_hat_s.add(h_hat); h_hat_prime_s.add(h); /* for test */ delta_s.add(delta); delta_prime_s.add(delta); // TODO previous: 0.1 v_s.add(0.1); v_hat_s.add(0.1); v_prime_s.add(0.1); v_hat_prime_s.add(0.1); System.out.println("done! t = " + t); } for (int t = t0; t < T; t++) { for (int s = t0; s < T; s++) { grad_mu_s.add(new double[n][K]); grad_mu_hat_s.add(new double[n][K]); grad_mu_prime_s.add(new double[n][K]); grad_mu_hat_prime_s.add(new double[n][K]); } grad_h_hat_s.add(new double[n][K]); grad_h_hat_prime_s.add(new double[n][K]); } /* end initialization */ /* outer for-loop */ double old_obj_1 = -1, old_obj_2 = -1; for (int iter = 0; iter < MAX_ITER; iter++) { // Scanner sc = new Scanner(System.in); int gu; gu = sc.nextInt(); System.out.println("====== iter = " + iter + " ======"); /** intrinsic feature * */ forward1(true, iter); backward1(true); compute_gradient1(iter); double new_obj_1 = 0; /* gradient descent: inner for-loop here */ int inner_iter_1 = 0; while (inner_iter_1 < INNER_ITER) { /* update variational parameters \hat{h} using gradient descent */ for (int t = 0; t < T - t0; t++) { double[][] h_hat_t = h_hat_s.get(t); double[][] grad_h_hat_t = grad_h_hat_s.get(t); for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { h_hat_t[i][k] += lr_1 * grad_h_hat_t[i][k]; } h_hat_s.set(t, h_hat_t); } /* update \hat{\mu} and \hat{V}, since both are function of \hat{h} */ forward1(false, iter); backward1(false); double obj1 = compute_objective1(); if (inner_iter_1 % 10 == 0) System.out.println("(1) iter = " + inner_iter_1 + ", obj 1 = " + obj1); if (inner_iter_1 != 0 && obj1 < new_obj_1) { lr_1 *= 0.8; break; } new_obj_1 = obj1; inner_iter_1 += 1; } if (inner_iter_1 == INNER_ITER) lr_1 *= 2; /* sample */ for (int t = 0; t < T - t0; t++) { double[][] samples = Operations.sample_multivariate_normal(mu_hat_s.get(t), v_hat_s.get(t), N_SAMPLES); double[][] h_t = new double[n][K]; for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { h_t[i][k] = samples[i][k]; } h_s.set(t, h_t); } /** impression feature * */ forward2(true); backward2(true); compute_gradient2(iter); double new_obj_2 = 0; /* gradient descent: inner for-loop here */ int inner_iter_2 = 0; while (inner_iter_2 < INNER_ITER) { /* update \hat{h}' using gradient descent */ for (int t = 0; t < T - t0; t++) { double[][] h_hat_prime_t = h_hat_prime_s.get(t); double[][] grad_h_hat_prime_t = grad_h_hat_prime_s.get(t); for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { h_hat_prime_t[i][k] += lr_2 * grad_h_hat_prime_t[i][k]; } h_hat_prime_s.set(t, h_hat_prime_t); } /* update \hat{\mu}' and \hat{V}', since both are function of \hat{h}' */ forward2(false); backward2(false); double obj2 = compute_objective2(); if (inner_iter_2 % 10 == 0) System.out.println("(2) iter = " + inner_iter_2 + ", obj 2 = " + obj2); if (inner_iter_2 != 0 && obj2 < new_obj_2) { lr_2 *= 0.8; break; } new_obj_2 = obj2; inner_iter_2 += 1; } if (inner_iter_2 == INNER_ITER) lr_2 *= 2; /* sample */ for (int t = 0; t < T - t0; t++) { double[][] samples = Operations.sample_multivariate_normal( mu_hat_prime_s.get(t), v_hat_prime_s.get(t), N_SAMPLES); double[][] h_prime_t = new double[n][K]; for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { h_prime_t[i][k] = samples[i][k]; } h_prime_s.set(t, h_prime_t); } /** output * */ for (int t = 0; t < T - t0; t++) { double[][] h_t = h_s.get(t); double[][] h_prime_t = h_prime_s.get(t); /* output filename: * ./res/<seed>_<sigma>/h_<time>_<iter>.txt */ FileParser.output( h_t, "./res/" + seed + "_" + delta_str + "/h_" + (t + t0) + "_" + iter + ".txt"); FileParser.output( h_prime_t, "./res/" + seed + "_" + delta_str + "/h_p_" + (t + t0) + "_" + iter + ".txt"); } /* check convergence */ double diff_1 = -(new_obj_1 - old_obj_1) / old_obj_1; double diff_2 = -(new_obj_2 - old_obj_2) / old_obj_2; if (iter != 0 && diff_1 < 1e-6 && diff_2 < 1e-6) { System.out.println("diff_1 = " + diff_1); System.out.println("diff_2 = " + diff_2); break; } old_obj_1 = new_obj_1; old_obj_2 = new_obj_2; } }
/** forward pass 2: update impression features (1) mu' (mu_prime_s) (2) variance V' (v_prime_s) */ public static void forward2(boolean update_grad) { for (int t1 = t0; t1 < T; t1++) { int t = t1 - t0; // System.out.println("forward 2;\tt = " + t1); if (t != 0) { double delta_t_prime = delta_prime_s.get(t); // delta'_t double[][] mu_prime_pre_t = mu_prime_s.get(t - 1); // mu'^{t-1} [t] double[][] h_hat_prime_t = h_hat_prime_s.get(t); // \hat{h}'^{t} (n*1) double V_prime_pre_t = v_prime_s.get(t - 1); // V'^{t-1} [t] /* calculate \mu */ double[][] mu_prime_t = new double[n][K]; double factor_1 = (delta_t_prime * delta_t_prime) / (delta_t_prime * delta_t_prime + sigma * sigma + V_prime_pre_t); double factor_2 = (sigma * sigma + V_prime_pre_t) / (delta_t_prime * delta_t_prime + sigma * sigma + V_prime_pre_t); for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { mu_prime_t[i][k] = factor_1 * mu_prime_pre_t[i][k] + factor_2 * h_hat_prime_t[i][k]; } /* calculate V */ double v_prime_t = factor_2 * delta_t_prime * delta_t_prime; /* update */ mu_prime_s.set(t, mu_prime_t); v_prime_s.set(t, v_prime_t); /* calculate and update grad_mu_prime */ if (update_grad) for (int s = 0; s < T - t0; s++) { double[][] grad_mu_prime_pre_t_s = grad_mu_prime_s.get((t - 1) * (T - t0) + s); double[][] grad_mu_prime_t_s = new double[n][K]; for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { grad_mu_prime_t_s[i][k] = factor_1 * grad_mu_prime_pre_t_s[i][k]; if (s == t) { grad_mu_prime_t_s[i][k] += factor_2; } } grad_mu_prime_s.set(t * (T - t0) + s, grad_mu_prime_t_s); } } else { /* for \mu'_i: ignore the first term in the summation */ /* for V': * option 1: use v_prime_init for all i * option 2: ignore v_prime_{t-1} */ /* double delta_t_prime = delta_prime_s.get(t); // delta'_t double[][] h_hat_prime_t = h_prime_s.get(t); // \hat{h}'^{t} (n*1) */ /* calculate new round of parameters */ /* double[] mu_prime_t = new double[n]; for (int i = 0; i < n; i++) { double c = (sigma*sigma) / (sigma*sigma + delta_t_prime*delta_t_prime); mu_prime_t[i] = c * h_hat_prime_t[i][0]; } double v_prime_t = v_prime_init; */ /* update */ /* mu_prime_s.set(t, mu_prime_t); v_prime_s.set(t, v_prime_t); */ } /* end for each t */ } }
/* * backward pass 1: update * (1) \hat{mu} (mu_hat_s) * (2) \hat{grad_mu} (grad_mu_hat_s) * (3) \hat{V} (v_hat_s) */ public static void backward1(boolean update_grad) { for (int t1 = T - 1; t1 > t0; t1--) { int t = t1 - t0; // System.out.println("backward 1;\tt = " + t1); if (t != T - 1 - t0) { double V_pre_t = v_s.get(t - 1); // V^{t-1} double V_hat_t = v_hat_s.get(t); // \hat{V}^{t} double[][] mu_pre_t = mu_s.get(t - 1); // \mu^{t-1} double[][] mu_hat_t = mu_hat_s.get(t); // \hat{\mu}^{t} [t-1] Matrix A_pre_t = new Matrix(AS.get(t - 1)); // A^{t-1} Matrix hprime_pre_t = new Matrix(h_prime_s.get(t - 1)); // h'^{t-1} Matrix ave_neighbors = A_pre_t.times(hprime_pre_t); // n * 1 /* calculate \hat{\mu} at time t-1 */ double factor_1 = (1 - lambda) * V_pre_t / (sigma * sigma + (1 - lambda) * (1 - lambda) * V_pre_t); double factor_2 = (sigma * sigma) / (sigma * sigma + (1 - lambda) * (1 - lambda) * V_pre_t); double[][] mu_hat_pre_t = new double[n][K]; for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { mu_hat_pre_t[i][k] = factor_1 * (mu_hat_t[i][k] - lambda * ave_neighbors.get(i, k)) + factor_2 * mu_pre_t[i][k]; } /* calculate \hat{V} at time t-1 */ double V_hat_pre_t = V_pre_t + factor_1 * factor_1 * (V_hat_t - (1 - lambda) * (1 - lambda) * V_pre_t - (sigma * sigma)); /* update \mu and V */ mu_hat_s.set(t - 1, mu_hat_pre_t); v_hat_s.set(t - 1, V_hat_pre_t); /* calculate and update grad_mu_hat at time t-1 */ if (update_grad) for (int s = 0; s < T - t0; s++) { double[][] grad_hat_t_s = grad_mu_hat_s.get(t * (T - t0) + s); double[][] grad_pre_t_s = grad_mu_s.get((t - 1) * (T - t0) + s); double[][] grad_hat_pre_t_s = new double[n][K]; for (int i = 0; i < n; i++) for (int k = 0; k < K; k++) { grad_hat_pre_t_s[i][k] = factor_1 * grad_hat_t_s[i][k] + factor_2 * grad_pre_t_s[i][k]; } grad_mu_hat_s.set((t - 1) * (T - t0) + s, grad_hat_pre_t_s); } } else { /* * initial condition for backward pass: * (1) \hat{mu}^{T} = mu^{T} * (2) \hat{V}^{T} = V^{T} * (3) \hat{grad_mu}^{T/s} = grad_mu^{T/s}, \forall s */ mu_hat_s.set(t, mu_s.get(t)); v_hat_s.set(t, v_s.get(t)); if (update_grad) for (int s = 0; s < T - t0; s++) { grad_mu_hat_s.set(t * (T - t0) + s, grad_mu_s.get(t * (T - t0) + s)); } } // Scanner sc = new Scanner(System.in); // int gu; gu = sc.nextInt(); /* end for each t */ } }
/** * SIGH... * * @return */ public BNF toBNF() { // first thing first, make a deep copy of current EBNF // then play / return with the copy EBNF ebnf = clone(); // auto generate new non terminal names StringIterator quanNames = new StringIterator("quan_{000}"); int oldHash = ebnf.hashCode(); int newHash = ebnf.hashCode(); boolean exceptionTriggered; do { oldHash = newHash; exceptionTriggered = false; Iterator<NonTerminal> i = ebnf.nonTerminals.keySet().iterator(); try { // travel through all non terminals while (i.hasNext()) { NonTerminal iii = i.next(); Iterator<? extends EBNFBranch> j = ebnf.nonTerminals.get(iii).iterator(); // travel through all branches for each non terminal while (j.hasNext()) { EBNFBranch jjj = j.next(); List l = jjj.getElementList(); // travel through all elements for each branch for (int n = 0; n < l.size(); n++) { if (l.get(n) instanceof Quantification) { // found a quantification Quantification q = ((Quantification) l.get(n)); // substitude it with a new non terminal NonTerminal newnt = new NonTerminal(quanNames.next()); l.set(n, newnt); // modify the element list for the new nt a little bit List<EBNFBranch> li = (List<EBNFBranch>) q.getBranchList(); if ((q.getMaxOccurrance() == 1) && (q.getMinOccurrance() == 0)) { // [..] boolean containsEpsilon = false; for (int k = 0; k < li.size(); k++) { if (Terminal.epsilon.equals(li.get(k).getElementList().get(0))) { // this branch contains epsilon // (branches that contain epsilon contains only 1 element) containsEpsilon = true; } } // add new epsilon branch if currently don't have one if (!containsEpsilon) { li.add(new EBNFBranch()); } } else if ((q.getMaxOccurrance() == -1) && (q.getMinOccurrance() == 0)) { boolean containsEpsilon = false; // {...} for (int k = 0; k < li.size(); k++) { if (Terminal.epsilon.equals(li.get(k).getElementList().get(0))) { containsEpsilon = true; // keep the only one epsilon branch untouched } else { // add the new non terminal to the end of // each non epsilon branch li.get(k).getElementList().add(newnt); } } if (!containsEpsilon) { li.add(new EBNFBranch()); } } // add the new non terminal to new EBNF ebnf.nonTerminals.put(newnt, li); } } } } } catch (ConcurrentModificationException e) { exceptionTriggered = true; } newHash = ebnf.hashCode(); } while ((newHash != oldHash) || exceptionTriggered); return new BNF(ebnf.startSymbol, ebnf.nonTerminals); }
/** set changes the element at the given index */ public void testSet() { List full = populatedArray(3); assertEquals(two, full.set(2, four)); assertEquals(4, ((Integer) full.get(2)).intValue()); }
public void setLine(int index, TicketLineInfo oLine) { oLine.setTicket(m_sId, index); m_aLines.set(index, oLine); }