zzh
/
gatk-3.8
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

moved a bunch of files over to the logging system. In some cases I ballparked the severity level of an error, so if you see something wrong feel free to make changes. 

git-svn-id: file:///humgen/gsa-scr1/gsa-engineering/svn_contents/trunk@211 348d0f76-0448-11de-a6fe-93d51630548a
This commit is contained in:
aaron 2009-03-27 14:02:55 +00:00
parent 826781a760
commit 230c1ad161
4 changed files with 220 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
java/src/org/broadinstitute/sting/utils/FastaSequenceFile2.java
View File

@ -14,6 +14,7 @@ import net.sf.samtools.SAMSequenceRecord;
import net.sf.samtools.util.AsciiLineReader; import net.sf.samtools.util.AsciiLineReader;
import net.sf.samtools.util.StringUtil; import net.sf.samtools.util.StringUtil;
import net.sf.samtools.util.RuntimeIOException; import net.sf.samtools.util.RuntimeIOException;
import org.apache.log4j.Logger;
/** /**
* Implementation of ReferenceSequenceFile for reading from FASTA files. * Implementation of ReferenceSequenceFile for reading from FASTA files.
@ -30,6 +31,11 @@ public class FastaSequenceFile2 implements ReferenceSequenceFile {
private SAMSequenceDictionary sequenceDictionary = null; private SAMSequenceDictionary sequenceDictionary = null;
private String currentContigName = null; private String currentContigName = null;
/**
* our log, which we want to capture anything from this class
*/
private static Logger logger = Logger.getLogger(FastaSequenceFile2.class);
/** /**
* Set to true to see lots of debugging output during operation * Set to true to see lots of debugging output during operation
*/ */
@ -129,9 +135,9 @@ public class FastaSequenceFile2 implements ReferenceSequenceFile {
assert contig1Rec != null : "Contig2 record is null: " + contig2; assert contig1Rec != null : "Contig2 record is null: " + contig2;
if ( DEBUG ) if ( DEBUG )
System.out.printf("Contig1=(%s, %d), contig2=(%s, %d)%n", logger.debug(String.format("Contig1=(%s, %d), contig2=(%s, %d)%n",
contig1, contig1Rec.getSequenceIndex(), contig1, contig1Rec.getSequenceIndex(),
contig2, contig2Rec.getSequenceIndex()); contig2, contig2Rec.getSequenceIndex()));
int startIndex = Math.min(contig1Rec.getSequenceIndex(), contig2Rec.getSequenceIndex()); int startIndex = Math.min(contig1Rec.getSequenceIndex(), contig2Rec.getSequenceIndex());
int lastIndex = Math.max(contig1Rec.getSequenceIndex(), contig2Rec.getSequenceIndex()); int lastIndex = Math.max(contig1Rec.getSequenceIndex(), contig2Rec.getSequenceIndex());
@ -141,14 +147,14 @@ public class FastaSequenceFile2 implements ReferenceSequenceFile {
SAMSequenceRecord rec = seqDict.getSequence(i); SAMSequenceRecord rec = seqDict.getSequence(i);
bytesToTraverse += rec.getSequenceLength(); bytesToTraverse += rec.getSequenceLength();
if ( DEBUG ) if ( DEBUG )
System.out.printf(" -> Traversing from %15s to %15s requires reading at least %10d bytes to pass contig %15s, total bytes %10d%n", logger.debug(String.format(" -> Traversing from %15s to %15s requires reading at least %10d bytes to pass contig %15s, total bytes %10d%n",
contig1, contig2, rec.getSequenceLength(), rec.getSequenceName(), bytesToTraverse); contig1, contig2, rec.getSequenceLength(), rec.getSequenceName(), bytesToTraverse));
} }
if ( contig1Rec.getSequenceIndex() > contig2Rec.getSequenceIndex() ) if ( contig1Rec.getSequenceIndex() > contig2Rec.getSequenceIndex() )
bytesToTraverse *= -1; // we are going backward! bytesToTraverse *= -1; // we are going backward!
if ( DEBUG ) System.out.printf(" -> total distance is %d%n", bytesToTraverse); if ( DEBUG ) logger.debug(String.format(" -> total distance is %d%n", bytesToTraverse));
return bytesToTraverse; return bytesToTraverse;
} }
@ -180,13 +186,13 @@ public class FastaSequenceFile2 implements ReferenceSequenceFile {
* @return true on success * @return true on success
*/ */
public boolean seekToContig(final String seekContig, boolean enableBacktracking ) { public boolean seekToContig(final String seekContig, boolean enableBacktracking ) {
if ( DEBUG ) System.out.printf("seekToContig( %s, %b )%n", seekContig, enableBacktracking); if ( DEBUG ) logger.debug(String.format("seekToContig( %s, %b )%n", seekContig, enableBacktracking));
String curContig = getContigName(); String curContig = getContigName();
String nextContig = null; String nextContig = null;
if ( curContig == null ) { if ( curContig == null ) {
System.out.printf("CurrentContig is null"); logger.info(String.format("CurrentContig is null"));
if ( this.sequenceDictionary == null ) if ( this.sequenceDictionary == null )
throw new PicardException( String.format("Seeking within contigs requires FASTA dictionary, but none was available for %s", this.file )); throw new PicardException( String.format("Seeking within contigs requires FASTA dictionary, but none was available for %s", this.file ));
@ -217,7 +223,7 @@ public class FastaSequenceFile2 implements ReferenceSequenceFile {
return false; // we're not going backwards just yet return false; // we're not going backwards just yet
} }
else { else {
if ( DEBUG ) System.out.printf("Going to seek to contig %s with skip %d%n", seekContig, dist); if ( DEBUG ) logger.debug(String.format("Going to seek to contig %s with skip %d%n", seekContig, dist));
// we're actually going to jump somewhere, so prepare the state // we're actually going to jump somewhere, so prepare the state
this.nextContigName = null; // reset the contig info this.nextContigName = null; // reset the contig info
@ -256,7 +262,7 @@ public class FastaSequenceFile2 implements ReferenceSequenceFile {
* @return null if there are no more sequences in the fasta stream * @return null if there are no more sequences in the fasta stream
*/ */
public ReferenceSequence nextSequence() { public ReferenceSequence nextSequence() {
if ( DEBUG ) System.out.printf("Calling nextSequence()%n"); if ( DEBUG ) logger.debug(String.format("Calling nextSequence()%n"));
// Read the header line // Read the header line
currentContigName = getNextContigName(); currentContigName = getNextContigName();
@ -309,8 +315,8 @@ public class FastaSequenceFile2 implements ReferenceSequenceFile {
this.nextContigName = null; // we no longer know what the next contig name is this.nextContigName = null; // we no longer know what the next contig name is
if ( DEBUG ) System.out.printf(" => nextSequence() is returning %s, known length = %d%n", this.currentContigName, knownLength); if ( DEBUG ) logger.debug(String.format(" => nextSequence() is returning %s, known length = %d%n", this.currentContigName, knownLength));
if ( DEBUG ) System.out.printf(" => nextSequence() next is %s%n", this.getNextContigName()); if ( DEBUG ) logger.debug(String.format(" => nextSequence() next is %s%n", this.getNextContigName()));
return new ReferenceSequence(currentContigName, index, bases); return new ReferenceSequence(currentContigName, index, bases);
} }
@ -326,7 +332,7 @@ public class FastaSequenceFile2 implements ReferenceSequenceFile {
* @return the name of the next contig, or null if there is no next contig * @return the name of the next contig, or null if there is no next contig
*/ */
public String getNextContigName() { public String getNextContigName() {
if ( DEBUG ) System.out.printf("getNextContigName() => %s%n", this.nextContigName); if ( DEBUG ) logger.debug(String.format("getNextContigName() => %s%n", this.nextContigName));
if ( this.nextContigName == null ) { if ( this.nextContigName == null ) {
// If it's not null, we've already looked up the next contig name, just return it and happily continue // If it's not null, we've already looked up the next contig name, just return it and happily continue
@ -334,7 +340,7 @@ public class FastaSequenceFile2 implements ReferenceSequenceFile {
this.nextContigName = readNextContigName(); this.nextContigName = readNextContigName();
} }
if ( DEBUG ) System.out.printf("nextContigName is now %s%n", nextContigName); if ( DEBUG ) logger.debug(String.format("nextContigName is now %s%n", nextContigName));
return this.nextContigName; return this.nextContigName;
} }
@ -400,7 +406,7 @@ public class FastaSequenceFile2 implements ReferenceSequenceFile {
if ( foundIndex == ourIndex ) { if ( foundIndex == ourIndex ) {
// we found our target! // we found our target!
this.nextContigName = foundContig; // store the right answer this.nextContigName = foundContig; // store the right answer
if ( DEBUG ) System.out.printf("seekForNextContig found %s%n", foundContig); if ( DEBUG ) logger.debug(String.format("seekForNextContig found %s%n", foundContig));
return foundContig; return foundContig;
} }
else if ( foundIndex <= ourIndex ) else if ( foundIndex <= ourIndex )

32
java/src/org/broadinstitute/sting/utils/FileProgressTracker.java
View File

@ -1,5 +1,7 @@
package org.broadinstitute.sting.utils; package org.broadinstitute.sting.utils;
import org.apache.log4j.Logger;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
@ -43,6 +45,12 @@ public class FileProgressTracker<T> implements Iterator<T> {
this(file, it, channel, DEFAULT_HISTORY_SIZE); this(file, it, channel, DEFAULT_HISTORY_SIZE);
} }
/**
* our log, which we want to capture anything from this class
*/
private static Logger logger = Logger.getLogger(FileProgressTracker.class);
// ----------------------------------------------------------------- // -----------------------------------------------------------------
// //
// iterator support // iterator support
@ -126,18 +134,18 @@ public class FileProgressTracker<T> implements Iterator<T> {
} }
public void printStatus() { public void printStatus() {
System.out.printf("FileProgressTracker:%n"); logger.debug(String.format("FileProgressTracker:%n"));
System.out.printf(" -> File size is: %d%n", getFileSize()); logger.debug(String.format(" -> File size is: %d%n", getFileSize()));
System.out.printf(" -> Sampling depth: %d%n", historyI); logger.debug(String.format(" -> Sampling depth: %d%n", historyI));
System.out.printf(" -> File position: %d%n", getPosition()); logger.debug(String.format(" -> File position: %d%n", getPosition()));
System.out.printf(" -> Number of records processed: %d%n", nRecordsProcessed()); logger.debug(String.format(" -> Number of records processed: %d%n", nRecordsProcessed()));
System.out.printf(" -> Average record size is %d%n", averageRecordSize()); logger.debug(String.format(" -> Average record size is %d%n", averageRecordSize()));
System.out.printf(" -> Elapsed time in secs is %.2f%n", elapsedTimeInSecs()); logger.debug(String.format(" -> Elapsed time in secs is %.2f%n", elapsedTimeInSecs()));
System.out.printf(" -> Processing rate (records per second) %.2f%n", processingRate()); logger.debug(String.format(" -> Processing rate (records per second) %.2f%n", processingRate()));
System.out.printf(" -> Estimated number of records in file %d%n", estRecordsInFile()); logger.debug(String.format(" -> Estimated number of records in file %d%n", estRecordsInFile()));
System.out.printf(" -> Estimated percent progress through file %.2f%n", estFractionProgressThroughFile() * 100.0); logger.debug(String.format(" -> Estimated percent progress through file %.2f%n", estFractionProgressThroughFile() * 100.0));
System.out.printf(" -> Estimated time for entire processing %.2f hrs / %.2f min / %.2f sec%n", estTimeTotal() / (60*60), estTimeTotal() / (60), estTimeTotal()); logger.debug(String.format(" -> Estimated time for entire processing %.2f hrs / %.2f min / %.2f sec%n", estTimeTotal() / (60*60), estTimeTotal() / (60), estTimeTotal()));
System.out.printf(" -> Estimated time remaining %.2f hrs / %.2f min / %.2f sec%n", estTimeRemaining() / (60*60), estTimeRemaining() / 60, estTimeRemaining()); logger.debug(String.format(" -> Estimated time remaining %.2f hrs / %.2f min / %.2f sec%n", estTimeRemaining() / (60*60), estTimeRemaining() / 60, estTimeRemaining()));
} }
public String progressMeter() { public String progressMeter() {

52
java/src/org/broadinstitute/sting/utils/RefHanger.java
View File

@ -1,6 +1,7 @@
package org.broadinstitute.sting.utils; package org.broadinstitute.sting.utils;
import org.broadinstitute.sting.utils.GenomeLoc; import org.broadinstitute.sting.utils.GenomeLoc;
import org.apache.log4j.Logger;
import java.util.List; import java.util.List;
import java.util.ArrayList; import java.util.ArrayList;
@ -8,9 +9,9 @@ import java.util.Arrays;
/** /**
* Hanging data off the reference sequence * Hanging data off the reference sequence
* * <p/>
* Supports in effect the following data structure * Supports in effect the following data structure
* * <p/>
* <-- reference bases: A T G C --> * <-- reference bases: A T G C -->
* d d d d * d d d d
* d d d d * d d d d
@ -18,7 +19,7 @@ import java.util.Arrays;
* d d d * d d d
* d d * d d
* d * d
* * <p/>
* Where the little d's are data associated with each position in the reference. * Where the little d's are data associated with each position in the reference.
* Supports adding and removing data to either side of the data structure, as well as * Supports adding and removing data to either side of the data structure, as well as
* randomly accessing data anywhere within window. * randomly accessing data anywhere within window.
@ -32,6 +33,11 @@ public class RefHanger<T> {
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
ArrayList<Hanger> hangers; ArrayList<Hanger> hangers;
/**
* our log, which we want to capture anything from this class
*/
private static Logger logger = Logger.getLogger(RefHanger.class);
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
// //
// Info structure // Info structure
@ -46,9 +52,17 @@ public class RefHanger<T> {
this.data = data; this.data = data;
} }
public final ArrayList<T> getData() { return data; } public final ArrayList<T> getData() {
public final int size() { return this.data.size(); } return data;
public final T get(int i) { return this.data.get(i); } }
public final int size() {
return this.data.size();
}
public final T get(int i) {
return this.data.get(i);
}
} }
@ -66,15 +80,26 @@ public class RefHanger<T> {
//System.out.printf("leftLoc is %s%n", getLeftLoc()); //System.out.printf("leftLoc is %s%n", getLeftLoc());
} }
protected int getLeftOffset() { return 0; } protected int getLeftOffset() {
protected int getRightOffset() { return hangers.size() - 1; } return 0;
}
protected int getRightOffset() {
return hangers.size() - 1;
}
protected int getOffset(GenomeLoc loc) { protected int getOffset(GenomeLoc loc) {
//System.out.printf("Loc: %s vs %s%n", loc, getLeftLoc()); //System.out.printf("Loc: %s vs %s%n", loc, getLeftLoc());
return loc.minus(getLeftLoc()); return loc.minus(getLeftLoc());
} }
public GenomeLoc getLeftLoc() { return hangers.get(getLeftOffset()).loc; } public GenomeLoc getLeftLoc() {
public GenomeLoc getRightLoc() { return hangers.get(getRightOffset()).loc; } return hangers.get(getLeftOffset()).loc;
}
public GenomeLoc getRightLoc() {
return hangers.get(getRightOffset()).loc;
}
public boolean hasLocation(GenomeLoc loc) { public boolean hasLocation(GenomeLoc loc) {
return !isEmpty() && loc.isBetween(getLeftLoc(), getRightLoc()); return !isEmpty() && loc.isBetween(getLeftLoc(), getRightLoc());
@ -83,6 +108,7 @@ public class RefHanger<T> {
public boolean isEmpty() { public boolean isEmpty() {
return hangers.isEmpty(); return hangers.isEmpty();
} }
public boolean hasHangers() { public boolean hasHangers() {
return !isEmpty(); return !isEmpty();
} }
@ -193,15 +219,15 @@ public class RefHanger<T> {
} }
public void printState() { public void printState() {
System.out.printf("Hanger:%n"); logger.info("Hanger: ");
for (Hanger hanger : hangers) { for (Hanger hanger : hangers) {
System.out.printf(" -> %s => %s:%n", hanger.loc, Utils.join("/", hanger.data) ); logger.info(String.format(" -> %s => %s:%n", hanger.loc, Utils.join("/", hanger.data)));
} }
} }
/** /**
* Pushes locations on the right until we reach the expected position for pos. * Pushes locations on the right until we reach the expected position for pos.
* * <p/>
* For example, if we have chr1:1 and 2 in the hanger, and we push 4 into the hangers * For example, if we have chr1:1 and 2 in the hanger, and we push 4 into the hangers
* this function will add 3 -> {} to the hanger too * this function will add 3 -> {} to the hanger too
* *

134
java/src/org/broadinstitute/sting/utils/Utils.java
View File

@ -11,6 +11,8 @@ import java.io.FileNotFoundException;
import java.io.FileReader; import java.io.FileReader;
import java.io.BufferedReader; import java.io.BufferedReader;
import org.apache.log4j.Logger;
/** /**
* Created by IntelliJ IDEA. * Created by IntelliJ IDEA.
* User: depristo * User: depristo
@ -19,25 +21,32 @@ import java.io.BufferedReader;
* To change this template use File | Settings | File Templates. * To change this template use File | Settings | File Templates.
*/ */
public class Utils { public class Utils {
/**
* our log, which we want to capture anything from this class
*/
private static Logger logger = Logger.getLogger(FileProgressTracker.class);
public static void warnUser(final String msg) { public static void warnUser(final String msg) {
System.out.printf("********************************************************************************%n"); logger.warn(String.format("********************************************************************************%n"));
System.out.printf("* WARNING:%n"); logger.warn(String.format("* WARNING:%n"));
System.out.printf("*%n"); logger.warn(String.format("*%n"));
System.out.printf("* %s%n", msg); logger.warn(String.format("* %s%n", msg));
System.out.printf("********************************************************************************%n"); logger.warn(String.format("********************************************************************************%n"));
} }
public static void scareUser(final String msg) { public static void scareUser(final String msg) {
System.out.printf("********************************************************************************%n"); logger.fatal(String.format("********************************************************************************%n"));
System.out.printf("* ERROR:%n"); logger.fatal(String.format("* ERROR:%n"));
System.out.printf("*%n"); logger.fatal(String.format("*%n"));
System.out.printf("* %s%n", msg); logger.fatal(String.format("* %s%n", msg));
System.out.printf("********************************************************************************%n"); logger.fatal(String.format("********************************************************************************%n"));
throw new RuntimeException(msg); throw new RuntimeException(msg);
} }
/** Returns a new list built from those objects found in collection <c> that satisfy the /**
* Returns a new list built from those objects found in collection <c> that satisfy the
* predicate ( i.e. pred.apply() is true for the objects in th eresulting list ). * predicate ( i.e. pred.apply() is true for the objects in th eresulting list ).
*
* @param pred filtering condition ( objects, for which pred.apply() is true pass the filter ) * @param pred filtering condition ( objects, for which pred.apply() is true pass the filter )
* @param c collection to filter (will not be modified) * @param c collection to filter (will not be modified)
* @return new list built from elements of <c> passing the filter * @return new list built from elements of <c> passing the filter
@ -56,7 +65,8 @@ public class Utils {
return filtered; return filtered;
} }
/** Removes from the collection <c> all the elements that do not pass the filter (i.e. those elements, /**
* Removes from the collection <c> all the elements that do not pass the filter (i.e. those elements,
* for which pred.apply() is false ). This is an in-place method - the argument is modified, and no new * for which pred.apply() is false ). This is an in-place method - the argument is modified, and no new
* objects are created/copied. Collection's iterator (as returned by iterator()) must implement * objects are created/copied. Collection's iterator (as returned by iterator()) must implement
* optional remove() interface method that allows multiple subsequent removals of elements from the * optional remove() interface method that allows multiple subsequent removals of elements from the
@ -67,6 +77,7 @@ public class Utils {
* with other, custom lists that 1) do not inherit (are not instanceof) from ArrayList and 2) do not implement * with other, custom lists that 1) do not inherit (are not instanceof) from ArrayList and 2) do not implement
* fast (constant time) remove() operation, the performance can degrade significantly (linear traversal times, * fast (constant time) remove() operation, the performance can degrade significantly (linear traversal times,
* e.g., linear removal ~ N^2). * e.g., linear removal ~ N^2).
*
* @param pred filtering condition (only elements, for which pred.apply() is true will be kept in the collection) * @param pred filtering condition (only elements, for which pred.apply() is true will be kept in the collection)
* @param c collection to filter (will be modified - should be mutable and should implement remove() ) * @param c collection to filter (will be modified - should be mutable and should implement remove() )
* @return reference to the same (modified) collection <c> * @return reference to the same (modified) collection <c>
@ -213,8 +224,13 @@ public class Utils {
return (1.0 * sum) / i; return (1.0 * sum) / i;
} }
public static double average(List<Long> vals) { return average(vals, vals.size()); } public static double average(List<Long> vals) {
public static double averageDouble(List<Double> vals) { return averageDouble(vals, vals.size()); } return average(vals, vals.size());
}
public static double averageDouble(List<Double> vals) {
return averageDouble(vals, vals.size());
}
public static boolean setupRefContigOrdering(final ReferenceSequenceFile refFile) { public static boolean setupRefContigOrdering(final ReferenceSequenceFile refFile) {
final SAMSequenceDictionary seqDict = refFile.getSequenceDictionary(); final SAMSequenceDictionary seqDict = refFile.getSequenceDictionary();
@ -227,13 +243,13 @@ public class Utils {
if (refContigs != null) { if (refContigs != null) {
int i = 0; int i = 0;
System.out.printf("Prepared reference sequence contig dictionary%n order ->"); logger.info(String.format("Prepared reference sequence contig dictionary%n order ->"));
for (SAMSequenceRecord contig : refContigs) { for (SAMSequenceRecord contig : refContigs) {
System.out.printf(" %s (%d bp)", contig.getSequenceName(), contig.getSequenceLength()); logger.info(String.format(" %s (%d bp)", contig.getSequenceName(), contig.getSequenceLength()));
refContigOrdering.put(contig.getSequenceName(), i); refContigOrdering.put(contig.getSequenceName(), i);
i++; i++;
} }
System.out.printf("%n Total elements -> %d%n", refContigOrdering.size()); logger.info(String.format("%n Total elements -> %d%n", refContigOrdering.size()));
} }
GenomeLoc.setContigOrdering(refContigOrdering); GenomeLoc.setContigOrdering(refContigOrdering);
@ -242,62 +258,62 @@ public class Utils {
// Java Generics can't do primitive types, so I had to do this the simplistic way // Java Generics can't do primitive types, so I had to do this the simplistic way
public static Integer[] SortPermutation(final int[] A) public static Integer[] SortPermutation(final int[] A) {
{ class comparator implements Comparator {
class comparator implements Comparator public int compare(Object a, Object b) {
{ if (A[(Integer) a] < A[(Integer) b]) {
public int compare(Object a, Object b) return -1;
{ }
if (A[(Integer)a] < A[(Integer)b]) { return -1; } if (A[(Integer) a] == A[(Integer) b]) {
if (A[(Integer)a] == A[(Integer)b]) { return 0; } return 0;
if (A[(Integer)a] > A[(Integer)b]) { return 1; } }
if (A[(Integer) a] > A[(Integer) b]) {
return 1;
}
return 0; return 0;
} }
} }
Integer[] permutation = new Integer[A.length]; Integer[] permutation = new Integer[A.length];
for (int i = 0; i < A.length; i++) for (int i = 0; i < A.length; i++) {
{
permutation[i] = i; permutation[i] = i;
} }
Arrays.sort(permutation, new comparator()); Arrays.sort(permutation, new comparator());
return permutation; return permutation;
} }
public static Integer[] SortPermutation(final double[] A) public static Integer[] SortPermutation(final double[] A) {
{ class comparator implements Comparator {
class comparator implements Comparator public int compare(Object a, Object b) {
{ if (A[(Integer) a] < A[(Integer) b]) {
public int compare(Object a, Object b) return -1;
{ }
if (A[(Integer)a] < A[(Integer)b]) { return -1; } if (A[(Integer) a] == A[(Integer) b]) {
if (A[(Integer)a] == A[(Integer)b]) { return 0; } return 0;
if (A[(Integer)a] > A[(Integer)b]) { return 1; } }
if (A[(Integer) a] > A[(Integer) b]) {
return 1;
}
return 0; return 0;
} }
} }
Integer[] permutation = new Integer[A.length]; Integer[] permutation = new Integer[A.length];
for (int i = 0; i < A.length; i++) for (int i = 0; i < A.length; i++) {
{
permutation[i] = i; permutation[i] = i;
} }
Arrays.sort(permutation, new comparator()); Arrays.sort(permutation, new comparator());
return permutation; return permutation;
} }
public static <T extends Comparable> Integer[] SortPermutation( List<T> A ) public static <T extends Comparable> Integer[] SortPermutation(List<T> A) {
{
final Object[] data = A.toArray(); final Object[] data = A.toArray();
class comparator implements Comparator<Integer> class comparator implements Comparator<Integer> {
{ public int compare(Integer a, Integer b) {
public int compare(Integer a, Integer b)
{
return ((T) data[a]).compareTo(data[b]); return ((T) data[a]).compareTo(data[b]);
} }
} }
Integer[] permutation = new Integer[A.size()]; Integer[] permutation = new Integer[A.size()];
for (int i = 0; i < A.size(); i++) for (int i = 0; i < A.size(); i++) {
{
permutation[i] = i; permutation[i] = i;
} }
Arrays.sort(permutation, new comparator()); Arrays.sort(permutation, new comparator());
@ -305,41 +321,33 @@ public class Utils {
} }
public static int[] PermuteArray(int[] array, Integer[] permutation) public static int[] PermuteArray(int[] array, Integer[] permutation) {
{
int[] output = new int[array.length]; int[] output = new int[array.length];
for (int i = 0; i < output.length; i++) for (int i = 0; i < output.length; i++) {
{
output[i] = array[permutation[i]]; output[i] = array[permutation[i]];
} }
return output; return output;
} }
public static double[] PermuteArray(double[] array, Integer[] permutation) public static double[] PermuteArray(double[] array, Integer[] permutation) {
{
double[] output = new double[array.length]; double[] output = new double[array.length];
for (int i = 0; i < output.length; i++) for (int i = 0; i < output.length; i++) {
{
output[i] = array[permutation[i]]; output[i] = array[permutation[i]];
} }
return output; return output;
} }
public static Object[] PermuteArray(Object[] array, Integer[] permutation) public static Object[] PermuteArray(Object[] array, Integer[] permutation) {
{
Object[] output = new Object[array.length]; Object[] output = new Object[array.length];
for (int i = 0; i < output.length; i++) for (int i = 0; i < output.length; i++) {
{
output[i] = array[permutation[i]]; output[i] = array[permutation[i]];
} }
return output; return output;
} }
public static String[] PermuteArray(String[] array, Integer[] permutation) public static String[] PermuteArray(String[] array, Integer[] permutation) {
{
String[] output = new String[array.length]; String[] output = new String[array.length];
for (int i = 0; i < output.length; i++) for (int i = 0; i < output.length; i++) {
{
output[i] = array[permutation[i]]; output[i] = array[permutation[i]];
} }
return output; return output;