Classes

Class	Line #	Total Statements	Complexity	Uncovered Elements	TOTAL Coverage	Actions
SparseMatrix	33	58	27	18	0.8282%	Show methods

Class SparseMatrix

Class SparseMatrix	Line # 33	Total Statements 58	Complexity 27	Uncovered Elements 18	TOTAL Coverage 0.8282%
SparseMatrix(double[][])   SparseMatrix(double[][])	4646	11.011	5.05	1.01	0.94736844 0.9473684494.7%
getValue(int,int) : double   getValue(int,int) : double	7676	1.01	1.01	0.00	1.0 1.0100%
setValue(int,int,double) : void   setValue(int,int,double) : void	8585	3.03	2.02	0.00	1.0 1.0100%
getColumn(int) : double[]   getColumn(int) : double[]	9898	5.05	2.02	7.07	0.0 0.00%
copy() : MatrixI   copy() : MatrixI	111111	4.04	2.02	6.06	0.0 0.00%
transpose() : MatrixI   transpose() : MatrixI	122122	6.06	3.03	0.00	1.0 1.0100%
preMultiply(MatrixI) : MatrixI   preMultiply(MatrixI) : MatrixI	156156	18.018	8.08	0.00	1.0 1.0100%
divideValue(int,int,double) : double   divideValue(int,int,double) : double	206206	4.04	2.02	2.02	0.6666667 0.666666766.7%
addValue(int,int,double) : double   addValue(int,int,double) : double	217217	2.02	1.01	0.00	1.0 1.0100%
getFillRatio() : float   getFillRatio() : float	230230	4.04	1.01	0.00	1.0 1.0100%

 

Contributing tests

Contributing tests

Select all

	Test contribution	Test	Result	Actions
	0.5	jalview.math.SparseMatrixTest.testPreMultiply_sparseProductjalview.math.SparseMatrixTest.testPreMultiply_sparseProduct	1PASS
	0.46	jalview.math.SparseMatrixTest.testPreMultiplyjalview.math.SparseMatrixTest.testPreMultiply	1PASS
	0.46	jalview.math.SparseMatrixTest.testPostMultiplyjalview.math.SparseMatrixTest.testPostMultiply	1PASS
	0.35	jalview.math.SparseMatrixTest.testTqli_matchesMatrixjalview.math.SparseMatrixTest.testTqli_matchesMatrix	1PASS
	0.35	jalview.math.SparseMatrixTest.testTred_reproduciblejalview.math.SparseMatrixTest.testTred_reproducible	1PASS
	0.35	jalview.math.SparseMatrixTest.testTred_matchesMatrixjalview.math.SparseMatrixTest.testTred_matchesMatrix	1PASS
	0.32	jalview.math.SparseMatrixTest.testTransposejalview.math.SparseMatrixTest.testTranspose	1PASS
	0.24	jalview.math.SparseMatrixTest.testFillRatiojalview.math.SparseMatrixTest.testFillRatio	1PASS
	0.22	jalview.math.SparseMatrixTest.testPreMultiply_tooManyColumnsjalview.math.SparseMatrixTest.testPreMultiply_tooManyColumns	1PASS
	0.22	jalview.math.SparseMatrixTest.testPreMultiply_tooFewColumnsjalview.math.SparseMatrixTest.testPreMultiply_tooFewColumns	1PASS
	0.21	jalview.math.SparseMatrixTest.testConstructorjalview.math.SparseMatrixTest.testConstructor	1PASS

 

Source view

1		/*
2		* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3		* Copyright (C) $$Year-Rel$$ The Jalview Authors
4		*
5		* This file is part of Jalview.
6		*
7		* Jalview is free software: you can redistribute it and/or
8		* modify it under the terms of the GNU General Public License
9		* as published by the Free Software Foundation, either version 3
10		* of the License, or (at your option) any later version.
11		*
12		* Jalview is distributed in the hope that it will be useful, but
13		* WITHOUT ANY WARRANTY; without even the implied warranty
14		* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15		* PURPOSE. See the GNU General Public License for more details.
16		*
17		* You should have received a copy of the GNU General Public License
18		* along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19		* The Jalview Authors are detailed in the 'AUTHORS' file.
20		*/
21		package jalview.math;
22
23		import jalview.ext.android.SparseDoubleArray;
24
25		/**
26		* A variant of Matrix intended for use for sparse (mostly zero) matrices. This
27		* class uses a SparseDoubleArray to hold each row of the matrix. The sparse
28		* array only stores non-zero values. This gives a smaller memory footprint, and
29		* fewer matrix calculation operations, for mostly zero matrices.
30		*
31		* @author gmcarstairs
32		*/
		82% Uncovered Elements: 18 (100) Complexity: 27 Complexity Density: 0.47
33		public class SparseMatrix extends Matrix
34		{
35		/*
36		* we choose columns for the sparse arrays as this allows
37		* optimisation of the preMultiply() method used in PCA.run()
38		*/
39		SparseDoubleArray[] sparseColumns;
40
41		/**
42		* Constructor given data in [row][column] order
43		*
44		* @param v
45		*/
		94.7% Uncovered Elements: 1 (19) Complexity: 5 Complexity Density: 0.45
46	22	public SparseMatrix(double[][] v)...
47		{
48	22	rows = v.length;
49	22	if (rows > 0)
50		{
51	22	cols = v[0].length;
52		}
53	22	sparseColumns = new SparseDoubleArray[cols];
54
55		/*
56		* transpose v[row][col] into [col][row] order
57		*/
58	107	for (int col = 0; col < cols; col++)
59		{
60	85	SparseDoubleArray sparseColumn = new SparseDoubleArray();
61	85	sparseColumns[col] = sparseColumn;
62	522	for (int row = 0; row < rows; row++)
63		{
64	437	double value = v[row][col];
65	437	if (value != 0d)
66		{
67	184	sparseColumn.put(row, value);
68		}
69		}
70		}
71		}
72
73		/**
74		* Answers the value at row i, column j
75		*/
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
76	7019	@Override...
77		public double getValue(int i, int j)
78		{
79	7019	return sparseColumns[j].get(i);
80		}
81
82		/**
83		* Sets the value at row i, column j to val
84		*/
		100% Uncovered Elements: 0 (5) Complexity: 2 Complexity Density: 0.67
85	870	@Override...
86		public void setValue(int i, int j, double val)
87		{
88	870	if (val == 0d)
89		{
90	385	sparseColumns[j].delete(i);
91		}
92		else
93		{
94	485	sparseColumns[j].put(i, val);
95		}
96		}
97
		0% Uncovered Elements: 7 (7) Complexity: 2 Complexity Density: 0.4
98	0	@Override...
99		public double[] getColumn(int i)
100		{
101	0	double[] col = new double[height()];
102
103	0	SparseDoubleArray vals = sparseColumns[i];
104	0	for (int nonZero = 0; nonZero < vals.size(); nonZero++)
105		{
106	0	col[vals.keyAt(nonZero)] = vals.valueAt(nonZero);
107		}
108	0	return col;
109		}
110
		0% Uncovered Elements: 6 (6) Complexity: 2 Complexity Density: 0.5
111	0	@Override...
112		public MatrixI copy()
113		{
114	0	double[][] vals = new double[height()][width()];
115	0	for (int i = 0; i < height(); i++)
116		{
117	0	vals[i] = getRow(i);
118		}
119	0	return new SparseMatrix(vals);
120		}
121
		100% Uncovered Elements: 0 (10) Complexity: 3 Complexity Density: 0.5
122	1	@Override...
123		public MatrixI transpose()
124		{
125	1	double[][] out = new double[cols][rows];
126
127		/*
128		* for each column...
129		*/
130	4	for (int i = 0; i < cols; i++)
131		{
132		/*
133		* put non-zero values into the corresponding row
134		* of the transposed matrix
135		*/
136	3	SparseDoubleArray vals = sparseColumns[i];
137	7	for (int nonZero = 0; nonZero < vals.size(); nonZero++)
138		{
139	4	out[i][vals.keyAt(nonZero)] = vals.valueAt(nonZero);
140		}
141		}
142
143	1	return new SparseMatrix(out);
144		}
145
146		/**
147		* Answers a new matrix which is the product in.this. If the product contains
148		* less than 20% non-zero values, it is returned as a SparseMatrix, else as a
149		* Matrix.
150		* <p>
151		* This method is optimised for the sparse arrays which store column values
152		* for a SparseMatrix. Note that postMultiply is not so optimised. That would
153		* require redundantly also storing sparse arrays for the rows, which has not
154		* been done. Currently only preMultiply is used in Jalview.
155		*/
		100% Uncovered Elements: 0 (30) Complexity: 8 Complexity Density: 0.44
156	12	@Override...
157		public MatrixI preMultiply(MatrixI in)
158		{
159	12	if (in.width() != rows)
160		{
161	2	throw new IllegalArgumentException("Can't pre-multiply " + this.rows
162		+ " rows by " + in.width() + " columns");
163		}
164	10	double[][] tmp = new double[in.height()][this.cols];
165
166	10	long count = 0L;
167	34	for (int i = 0; i < in.height(); i++)
168		{
169	98	for (int j = 0; j < this.cols; j++)
170		{
171		/*
172		* result[i][j] is the vector product of
173		* in.row[i] and this.column[j]
174		* we only need to use non-zero values from the column
175		*/
176	74	SparseDoubleArray vals = sparseColumns[j];
177	74	boolean added = false;
178	161	for (int nonZero = 0; nonZero < vals.size(); nonZero++)
179		{
180	87	int myRow = vals.keyAt(nonZero);
181	87	double myValue = vals.valueAt(nonZero);
182	87	tmp[i][j] += (in.getValue(i, myRow) * myValue);
183	87	added = true;
184		}
185	74	if (added && tmp[i][j] != 0d)
186		{
187	41	count++; // non-zero entry in product
188		}
189		}
190		}
191
192		/*
193		* heuristic rule - if product is more than 80% zero
194		* then construct a SparseMatrix, else a Matrix
195		*/
196	10	if (count * 5 < in.height() * cols)
197		{
198	1	return new SparseMatrix(tmp);
199		}
200		else
201		{
202	9	return new Matrix(tmp);
203		}
204		}
205
		66.7% Uncovered Elements: 2 (6) Complexity: 2 Complexity Density: 0.5
206	146	@Override...
207		protected double divideValue(int i, int j, double divisor)
208		{
209	146	if (divisor == 0d)
210		{
211	0	return getValue(i, j);
212		}
213	146	double v = sparseColumns[j].divide(i, divisor);
214	146	return v;
215		}
216
		100% Uncovered Elements: 0 (2) Complexity: 1 Complexity Density: 0.5
217	1432	@Override...
218		protected double addValue(int i, int j, double addend)
219		{
220	1432	double v = sparseColumns[j].add(i, addend);
221	1432	return v;
222		}
223
224		/**
225		* Returns the fraction of the whole matrix size that is actually modelled in
226		* sparse arrays (normally, the non-zero values)
227		*
228		* @return
229		*/
		100% Uncovered Elements: 0 (4) Complexity: 1 Complexity Density: 0.25
230	1	public float getFillRatio()...
231		{
232	1	long count = 0L;
233	1	for (SparseDoubleArray col : sparseColumns)
234		{
235	5	count += col.size();
236		}
237	1	return count / (float) (height() * width());
238		}
239		}