baseCode - 0.2.5

Clover coverage report - baseCode - 0.2.5

Coverage timestamp: Tue Apr 12 2005 11:31:58 EDT

FRAMES NO FRAMES

file stats:	LOC:	200		Methods:	6
	NCLOC:	123		Classes:	1

30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover

Source file

Conditionals

Statements

Methods

TOTAL

RowAbsentFilter.java

81%

81.2%

100%

82.1%

 package baseCode.dataFilter;
 
 import java.util.Vector;
 
 import baseCode.dataStructure.matrix.NamedMatrix;
 import baseCode.dataStructure.matrix.StringMatrix2DNamed;
 
 /**
  * Filter a data matrix according to flags given in a separate matrix.
  * <p>
  * The flags can be 'A', 'P' or 'M', for absent, present and marginal, following the Affymetrix convention. By default,
  * Marginal flags are counted as "absent", but this can be changed by the user.
  * <p>
  * Copyright (c) 2004
  * </p>
  * <p>
  * Institution:: Columbia University
  * </p>
  * 
  * @author Paul Pavlidis
  * @version $Id: RowAbsentFilter.java,v 1.5 2004/07/27 03:18:58 pavlidis Exp $
  */
 public class RowAbsentFilter extends AbstractFilter implements Filter {
 
    private StringMatrix2DNamed flags = null;
 
    private double minPresentFraction = 0.0;
    private int minPresentCount = 0;
    private boolean keepMarginal = false;
    private boolean fractionIsSet = false;
    private boolean countIsSet = false;
    private boolean flagsSet = false;
 
    /**
     * @param f the matrix containing the flags.
     */
    public void setFlagMatrix( StringMatrix2DNamed f ) {
       if ( f == null ) {
          throw new IllegalArgumentException( "Flag matrix is null" );
       }
       flags = f;
       flagsSet = true;
    }
 
    /**
     * @param k the minimum fraction of present values that there must be, in order to keep the row.
     */
    public void setMinPresentFraction( double k ) {
       if ( k < 0.0 || k > 1.0 )
             throw new IllegalArgumentException(
                   "Min present fraction must be between 0 and 1, got " + k );
       minPresentFraction = k;
       fractionIsSet = true;
    }
 
    /**
     * @param k the minimum number of present values there must be in order to keep the row.
     */
    public void setMinPresentCount( int k ) {
       if ( k < 0 ) {
          throw new IllegalArgumentException(
                "Minimum present count must be > 0." );
       }
       minPresentCount = k;
       countIsSet = true;
    }
 
    /**
     * @param k whether to count 'marginal' as 'present'. Default is false.
     */
    public void setKeepMarginal( boolean k ) {
       keepMarginal = k;
    }
 
    /**
     * The data is going to be filtered in accordance to strings in 'flags'. These are either 'A', 'P' or 'M' for absent,
     * present and marginal.
     * 
     * @param data The input matrix
     * @return Matrix after filtering.
     */
    public NamedMatrix filter( NamedMatrix data ) {
 
       int numRows = data.rows();
       int numCols = data.columns();
 
       if ( minPresentCount > numCols ) {
          throw new IllegalStateException( "Minimum present count is set to "
                + minPresentCount + " but there are only " + numCols
                + " columns in the matrix." );
       }
 
       if ( flags == null ) {
          throw new IllegalStateException( "Flag matrix is null" );
       }
 
       // no filtering requested.
       if ( !fractionIsSet && !countIsSet ) {
          log.info( "No filtering was requested" );
          return data;
       }
 
       if ( !flagsSet ) {
          log.info( "No flag matrix was provided." );
          return data;
       }
 
       validateFlags( data );
 
       // nothing will happen.
       if ( minPresentFraction == 0.0 && minPresentCount == 0 ) {
          log
                .info( "Criteria are set too low to result in any changes to the input." );
          return data;
       }
 
       Vector MTemp = new Vector();
       Vector rowNames = new Vector();
 
       int kept = 0;
       for ( int i = 0; i < numRows; i++ ) {
          String rowName = data.getRowName( i );
 
          if ( !flags.containsRowName( rowName ) ) {
             log.debug( "Row " + rowName + " not found in flags, skipping." );
             continue;
          }
 
          int numPresent = 0;
          for ( int j = 0; j < numCols; j++ ) {
             String colName = data.getColName( j );
 
             if ( !flags.containsColumnName( colName ) ) {
                log.debug( "Column " + colName
                      + " not found in flags, skipping." );
                continue;
             }
 
             // count missing values in the data as "absent", whatever the
             // flag really is.
             if ( data.isMissing( i, j ) ) {
                //       log.debug( "Found missing data, counting as absent." );
                continue;
             }
 
             String flag = ( String ) flags.get( flags
                   .getRowIndexByName( rowName ), flags
                   .getColIndexByName( colName ) );
 
             if ( flags.isMissing( flags.getRowIndexByName( rowName ), flags
                   .getColIndexByName( colName ) ) ) {
                log
                      .warn( "Flags had no value for an item, counting as present." );
             } else if ( flag.equals( "A" ) ) {
                continue;
             } else if ( flag.equals( "M" ) && !keepMarginal ) {
                continue;
             } else if ( !flag.equals( "P" ) && !flag.equals( "M" ) ) {
                log.warn( "Found a flag I don't know about, ignoring " + flag
                      + " and counting as present." );
             }
 
             numPresent++;
          }
 
          /* decide whether this row is a keeper */
          if ( ( countIsSet && numPresent >= minPresentCount )
                || ( fractionIsSet && ( double ) numPresent / numCols >= minPresentFraction ) ) {
             MTemp.add( data.getRowObj( i ) );
             rowNames.add( rowName );
             kept++;
          }
       }
 
       NamedMatrix returnval = getOutputMatrix( data, MTemp.size(), numCols );
       for ( int i = 0; i < MTemp.size(); i++ ) {
          for ( int j = 0; j < numCols; j++ ) {
             returnval.set( i, j, ( ( Object[] ) MTemp.get( i ) )[j] );
          }
       }
       returnval.setColumnNames( data.getColNames() );
       returnval.setRowNames( rowNames );
 
       log.info( "There are " + kept + " rows left after filtering." );
 
       return ( returnval );
    }
 
    /**
     * @param data NamedMatrix
     * @todo this should check more carefully - actually test that the rows are all the same.
     */
    private void validateFlags( NamedMatrix data ) {
       if ( flags == null || flags.rows() < data.rows()
             || flags.columns() < data.columns() ) {
          throw new IllegalStateException( "Flags do not match data." );
       }
    }
 
 }

1		package baseCode.dataFilter;
2
3		import java.util.Vector;
4
5		import baseCode.dataStructure.matrix.NamedMatrix;
6		import baseCode.dataStructure.matrix.StringMatrix2DNamed;
7
8		/**
9		* Filter a data matrix according to flags given in a separate matrix.
10		* <p>
11		* The flags can be 'A', 'P' or 'M', for absent, present and marginal, following the Affymetrix convention. By default,
12		* Marginal flags are counted as "absent", but this can be changed by the user.
13		* <p>
14		* Copyright (c) 2004
15		* </p>
16		* <p>
17		* Institution:: Columbia University
18		* </p>
19		*
20		* @author Paul Pavlidis
21		* @version $Id: RowAbsentFilter.java,v 1.5 2004/07/27 03:18:58 pavlidis Exp $
22		*/
23		public class RowAbsentFilter extends AbstractFilter implements Filter {
24
25		private StringMatrix2DNamed flags = null;
26
27		private double minPresentFraction = 0.0;
28		private int minPresentCount = 0;
29		private boolean keepMarginal = false;
30		private boolean fractionIsSet = false;
31		private boolean countIsSet = false;
32		private boolean flagsSet = false;
33
34		/**
35		* @param f the matrix containing the flags.
36		*/
37	9	public void setFlagMatrix( StringMatrix2DNamed f ) {
38	9	if ( f == null ) {
39	1	throw new IllegalArgumentException( "Flag matrix is null" );
40		}
41	8	flags = f;
42	8	flagsSet = true;
43		}
44
45		/**
46		* @param k the minimum fraction of present values that there must be, in order to keep the row.
47		*/
48	2	public void setMinPresentFraction( double k ) {
49	2	if ( k < 0.0 \|\| k > 1.0 )
50	1	throw new IllegalArgumentException(
51		"Min present fraction must be between 0 and 1, got " + k );
52	1	minPresentFraction = k;
53	1	fractionIsSet = true;
54		}
55
56		/**
57		* @param k the minimum number of present values there must be in order to keep the row.
58		*/
59	6	public void setMinPresentCount( int k ) {
60	6	if ( k < 0 ) {
61	0	throw new IllegalArgumentException(
62		"Minimum present count must be > 0." );
63		}
64	6	minPresentCount = k;
65	6	countIsSet = true;
66		}
67
68		/**
69		* @param k whether to count 'marginal' as 'present'. Default is false.
70		*/
71	1	public void setKeepMarginal( boolean k ) {
72	1	keepMarginal = k;
73		}
74
75		/**
76		* The data is going to be filtered in accordance to strings in 'flags'. These are either 'A', 'P' or 'M' for absent,
77		* present and marginal.
78		*
79		* @param data The input matrix
80		* @return Matrix after filtering.
81		*/
82	7	public NamedMatrix filter( NamedMatrix data ) {
83
84	7	int numRows = data.rows();
85	7	int numCols = data.columns();
86
87	7	if ( minPresentCount > numCols ) {
88	1	throw new IllegalStateException( "Minimum present count is set to "
89		+ minPresentCount + " but there are only " + numCols
90		+ " columns in the matrix." );
91		}
92
93	6	if ( flags == null ) {
94	0	throw new IllegalStateException( "Flag matrix is null" );
95		}
96
97		// no filtering requested.
98	6	if ( !fractionIsSet && !countIsSet ) {
99	0	log.info( "No filtering was requested" );
100	0	return data;
101		}
102
103	6	if ( !flagsSet ) {
104	0	log.info( "No flag matrix was provided." );
105	0	return data;
106		}
107
108	6	validateFlags( data );
109
110		// nothing will happen.
111	6	if ( minPresentFraction == 0.0 && minPresentCount == 0 ) {
112	0	log
113		.info( "Criteria are set too low to result in any changes to the input." );
114	0	return data;
115		}
116
117	6	Vector MTemp = new Vector();
118	6	Vector rowNames = new Vector();
119
120	6	int kept = 0;
121	6	for ( int i = 0; i < numRows; i++ ) {
122	180	String rowName = data.getRowName( i );
123
124	180	if ( !flags.containsRowName( rowName ) ) {
125	0	log.debug( "Row " + rowName + " not found in flags, skipping." );
126	0	continue;
127		}
128
129	180	int numPresent = 0;
130	180	for ( int j = 0; j < numCols; j++ ) {
131	2160	String colName = data.getColName( j );
132
133	2160	if ( !flags.containsColumnName( colName ) ) {
134	0	log.debug( "Column " + colName
135		+ " not found in flags, skipping." );
136	0	continue;
137		}
138
139		// count missing values in the data as "absent", whatever the
140		// flag really is.
141	2160	if ( data.isMissing( i, j ) ) {
142		// log.debug( "Found missing data, counting as absent." );
143	30	continue;
144		}
145
146	2130	String flag = ( String ) flags.get( flags
147		.getRowIndexByName( rowName ), flags
148		.getColIndexByName( colName ) );
149
150	2130	if ( flags.isMissing( flags.getRowIndexByName( rowName ), flags
151		.getColIndexByName( colName ) ) ) {
152	6	log
153		.warn( "Flags had no value for an item, counting as present." );
154	2124	} else if ( flag.equals( "A" ) ) {
155	332	continue;
156	1792	} else if ( flag.equals( "M" ) && !keepMarginal ) {
157	20	continue;
158	1772	} else if ( !flag.equals( "P" ) && !flag.equals( "M" ) ) {
159	6	log.warn( "Found a flag I don't know about, ignoring " + flag
160		+ " and counting as present." );
161		}
162
163	1778	numPresent++;
164		}
165
166		/* decide whether this row is a keeper */
167	180	if ( ( countIsSet && numPresent >= minPresentCount )
168		\|\| ( fractionIsSet && ( double ) numPresent / numCols >= minPresentFraction ) ) {
169	134	MTemp.add( data.getRowObj( i ) );
170	134	rowNames.add( rowName );
171	134	kept++;
172		}
173		}
174
175	6	NamedMatrix returnval = getOutputMatrix( data, MTemp.size(), numCols );
176	6	for ( int i = 0; i < MTemp.size(); i++ ) {
177	134	for ( int j = 0; j < numCols; j++ ) {
178	1608	returnval.set( i, j, ( ( Object[] ) MTemp.get( i ) )[j] );
179		}
180		}
181	6	returnval.setColumnNames( data.getColNames() );
182	6	returnval.setRowNames( rowNames );
183
184	6	log.info( "There are " + kept + " rows left after filtering." );
185
186	6	return ( returnval );
187		}
188
189		/**
190		* @param data NamedMatrix
191		* @todo this should check more carefully - actually test that the rows are all the same.
192		*/
193	6	private void validateFlags( NamedMatrix data ) {
194	6	if ( flags == null \|\| flags.rows() < data.rows()
195		\|\| flags.columns() < data.columns() ) {
196	0	throw new IllegalStateException( "Flags do not match data." );
197		}
198		}
199
200		}