001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.commons.math.linear;
018
019 import java.math.BigDecimal;
020 import junit.framework.Test;
021 import junit.framework.TestCase;
022 import junit.framework.TestSuite;
023
024 import org.apache.commons.math.fraction.BigFraction;
025 import org.apache.commons.math.fraction.Fraction;
026 import org.apache.commons.math.fraction.FractionConversionException;
027 import org.apache.commons.math.fraction.FractionField;
028
029 /**
030 * Test cases for the {@link MatrixUtils} class.
031 *
032 * @version $Revision: 783702 $ $Date: 2009-06-11 04:54:02 -0400 (Thu, 11 Jun 2009) $
033 */
034
035 public final class MatrixUtilsTest extends TestCase {
036
037 protected double[][] testData = { {1d,2d,3d}, {2d,5d,3d}, {1d,0d,8d} };
038 protected double[][] nullMatrix = null;
039 protected double[] row = {1,2,3};
040 protected BigDecimal[] bigRow =
041 {new BigDecimal(1),new BigDecimal(2),new BigDecimal(3)};
042 protected String[] stringRow = {"1", "2", "3"};
043 protected Fraction[] fractionRow =
044 {new Fraction(1),new Fraction(2),new Fraction(3)};
045 protected double[][] rowMatrix = {{1,2,3}};
046 protected BigDecimal[][] bigRowMatrix =
047 {{new BigDecimal(1), new BigDecimal(2), new BigDecimal(3)}};
048 protected String[][] stringRowMatrix = {{"1", "2", "3"}};
049 protected Fraction[][] fractionRowMatrix =
050 {{new Fraction(1), new Fraction(2), new Fraction(3)}};
051 protected double[] col = {0,4,6};
052 protected BigDecimal[] bigCol =
053 {new BigDecimal(0),new BigDecimal(4),new BigDecimal(6)};
054 protected String[] stringCol = {"0","4","6"};
055 protected Fraction[] fractionCol =
056 {new Fraction(0),new Fraction(4),new Fraction(6)};
057 protected double[] nullDoubleArray = null;
058 protected double[][] colMatrix = {{0},{4},{6}};
059 protected BigDecimal[][] bigColMatrix =
060 {{new BigDecimal(0)},{new BigDecimal(4)},{new BigDecimal(6)}};
061 protected String[][] stringColMatrix = {{"0"}, {"4"}, {"6"}};
062 protected Fraction[][] fractionColMatrix =
063 {{new Fraction(0)},{new Fraction(4)},{new Fraction(6)}};
064
065 public MatrixUtilsTest(String name) {
066 super(name);
067 }
068
069
070 public static Test suite() {
071 TestSuite suite = new TestSuite(MatrixUtilsTest.class);
072 suite.setName("MatrixUtils Tests");
073 return suite;
074 }
075
076 public void testCreateRealMatrix() {
077 assertEquals(new BlockRealMatrix(testData),
078 MatrixUtils.createRealMatrix(testData));
079 try {
080 MatrixUtils.createRealMatrix(new double[][] {{1}, {1,2}}); // ragged
081 fail("Expecting IllegalArgumentException");
082 } catch (IllegalArgumentException ex) {
083 // expected
084 }
085 try {
086 MatrixUtils.createRealMatrix(new double[][] {{}, {}}); // no columns
087 fail("Expecting IllegalArgumentException");
088 } catch (IllegalArgumentException ex) {
089 // expected
090 }
091 try {
092 MatrixUtils.createRealMatrix(null); // null
093 fail("Expecting NullPointerException");
094 } catch (NullPointerException ex) {
095 // expected
096 }
097 }
098
099 public void testcreateFieldMatrix() {
100 assertEquals(new Array2DRowFieldMatrix<Fraction>(asFraction(testData)),
101 MatrixUtils.createFieldMatrix(asFraction(testData)));
102 assertEquals(new Array2DRowFieldMatrix<Fraction>(fractionColMatrix),
103 MatrixUtils.createFieldMatrix(fractionColMatrix));
104 try {
105 MatrixUtils.createFieldMatrix(asFraction(new double[][] {{1}, {1,2}})); // ragged
106 fail("Expecting IllegalArgumentException");
107 } catch (IllegalArgumentException ex) {
108 // expected
109 }
110 try {
111 MatrixUtils.createFieldMatrix(asFraction(new double[][] {{}, {}})); // no columns
112 fail("Expecting IllegalArgumentException");
113 } catch (IllegalArgumentException ex) {
114 // expected
115 }
116 try {
117 MatrixUtils.createFieldMatrix((Fraction[][])null); // null
118 fail("Expecting NullPointerException");
119 } catch (NullPointerException ex) {
120 // expected
121 }
122 }
123
124 @Deprecated
125 public void testCreateBigMatrix() {
126 assertEquals(new BigMatrixImpl(testData),
127 MatrixUtils.createBigMatrix(testData));
128 assertEquals(new BigMatrixImpl(BigMatrixImplTest.asBigDecimal(testData), true),
129 MatrixUtils.createBigMatrix(BigMatrixImplTest.asBigDecimal(testData), false));
130 assertEquals(new BigMatrixImpl(BigMatrixImplTest.asBigDecimal(testData), false),
131 MatrixUtils.createBigMatrix(BigMatrixImplTest.asBigDecimal(testData), true));
132 assertEquals(new BigMatrixImpl(bigColMatrix),
133 MatrixUtils.createBigMatrix(bigColMatrix));
134 assertEquals(new BigMatrixImpl(stringColMatrix),
135 MatrixUtils.createBigMatrix(stringColMatrix));
136 try {
137 MatrixUtils.createBigMatrix(new double[][] {{1}, {1,2}}); // ragged
138 fail("Expecting IllegalArgumentException");
139 } catch (IllegalArgumentException ex) {
140 // expected
141 }
142 try {
143 MatrixUtils.createBigMatrix(new double[][] {{}, {}}); // no columns
144 fail("Expecting IllegalArgumentException");
145 } catch (IllegalArgumentException ex) {
146 // expected
147 }
148 try {
149 MatrixUtils.createBigMatrix(nullMatrix); // null
150 fail("Expecting NullPointerException");
151 } catch (NullPointerException ex) {
152 // expected
153 }
154 }
155
156 public void testCreateRowRealMatrix() {
157 assertEquals(MatrixUtils.createRowRealMatrix(row),
158 new BlockRealMatrix(rowMatrix));
159 try {
160 MatrixUtils.createRowRealMatrix(new double[] {}); // empty
161 fail("Expecting IllegalArgumentException");
162 } catch (IllegalArgumentException ex) {
163 // expected
164 }
165 try {
166 MatrixUtils.createRowRealMatrix(null); // null
167 fail("Expecting NullPointerException");
168 } catch (NullPointerException ex) {
169 // expected
170 }
171 }
172
173 public void testCreateRowFieldMatrix() {
174 assertEquals(MatrixUtils.createRowFieldMatrix(asFraction(row)),
175 new Array2DRowFieldMatrix<Fraction>(asFraction(rowMatrix)));
176 assertEquals(MatrixUtils.createRowFieldMatrix(fractionRow),
177 new Array2DRowFieldMatrix<Fraction>(fractionRowMatrix));
178 try {
179 MatrixUtils.createRowFieldMatrix(new Fraction[] {}); // empty
180 fail("Expecting IllegalArgumentException");
181 } catch (IllegalArgumentException ex) {
182 // expected
183 }
184 try {
185 MatrixUtils.createRowFieldMatrix((Fraction[]) null); // null
186 fail("Expecting NullPointerException");
187 } catch (NullPointerException ex) {
188 // expected
189 }
190 }
191
192 @Deprecated
193 public void testCreateRowBigMatrix() {
194 assertEquals(MatrixUtils.createRowBigMatrix(row),
195 new BigMatrixImpl(rowMatrix));
196 assertEquals(MatrixUtils.createRowBigMatrix(bigRow),
197 new BigMatrixImpl(bigRowMatrix));
198 assertEquals(MatrixUtils.createRowBigMatrix(stringRow),
199 new BigMatrixImpl(stringRowMatrix));
200 try {
201 MatrixUtils.createRowBigMatrix(new double[] {}); // empty
202 fail("Expecting IllegalArgumentException");
203 } catch (IllegalArgumentException ex) {
204 // expected
205 }
206 try {
207 MatrixUtils.createRowBigMatrix(nullDoubleArray); // null
208 fail("Expecting NullPointerException");
209 } catch (NullPointerException ex) {
210 // expected
211 }
212 }
213
214 public void testCreateColumnRealMatrix() {
215 assertEquals(MatrixUtils.createColumnRealMatrix(col),
216 new BlockRealMatrix(colMatrix));
217 try {
218 MatrixUtils.createColumnRealMatrix(new double[] {}); // empty
219 fail("Expecting IllegalArgumentException");
220 } catch (IllegalArgumentException ex) {
221 // expected
222 }
223 try {
224 MatrixUtils.createColumnRealMatrix(null); // null
225 fail("Expecting NullPointerException");
226 } catch (NullPointerException ex) {
227 // expected
228 }
229 }
230
231 public void testCreateColumnFieldMatrix() {
232 assertEquals(MatrixUtils.createColumnFieldMatrix(asFraction(col)),
233 new Array2DRowFieldMatrix<Fraction>(asFraction(colMatrix)));
234 assertEquals(MatrixUtils.createColumnFieldMatrix(fractionCol),
235 new Array2DRowFieldMatrix<Fraction>(fractionColMatrix));
236
237 try {
238 MatrixUtils.createColumnFieldMatrix(new Fraction[] {}); // empty
239 fail("Expecting IllegalArgumentException");
240 } catch (IllegalArgumentException ex) {
241 // expected
242 }
243 try {
244 MatrixUtils.createColumnFieldMatrix((Fraction[]) null); // null
245 fail("Expecting NullPointerException");
246 } catch (NullPointerException ex) {
247 // expected
248 }
249 }
250
251 @Deprecated
252 public void testCreateColumnBigMatrix() {
253 assertEquals(MatrixUtils.createColumnBigMatrix(col),
254 new BigMatrixImpl(colMatrix));
255 assertEquals(MatrixUtils.createColumnBigMatrix(bigCol),
256 new BigMatrixImpl(bigColMatrix));
257 assertEquals(MatrixUtils.createColumnBigMatrix(stringCol),
258 new BigMatrixImpl(stringColMatrix));
259
260 try {
261 MatrixUtils.createColumnBigMatrix(new double[] {}); // empty
262 fail("Expecting IllegalArgumentException");
263 } catch (IllegalArgumentException ex) {
264 // expected
265 }
266 try {
267 MatrixUtils.createColumnBigMatrix(nullDoubleArray); // null
268 fail("Expecting NullPointerException");
269 } catch (NullPointerException ex) {
270 // expected
271 }
272 }
273
274 /**
275 * Verifies that the matrix is an identity matrix
276 */
277 protected void checkIdentityMatrix(RealMatrix m) {
278 for (int i = 0; i < m.getRowDimension(); i++) {
279 for (int j =0; j < m.getColumnDimension(); j++) {
280 if (i == j) {
281 assertEquals(m.getEntry(i, j), 1d, 0);
282 } else {
283 assertEquals(m.getEntry(i, j), 0d, 0);
284 }
285 }
286 }
287 }
288
289 public void testCreateIdentityMatrix() {
290 checkIdentityMatrix(MatrixUtils.createRealIdentityMatrix(3));
291 checkIdentityMatrix(MatrixUtils.createRealIdentityMatrix(2));
292 checkIdentityMatrix(MatrixUtils.createRealIdentityMatrix(1));
293 try {
294 MatrixUtils.createRealIdentityMatrix(0);
295 } catch (IllegalArgumentException ex) {
296 // expected
297 }
298 }
299
300 /**
301 * Verifies that the matrix is an identity matrix
302 */
303 protected void checkIdentityFieldMatrix(FieldMatrix<Fraction> m) {
304 for (int i = 0; i < m.getRowDimension(); i++) {
305 for (int j =0; j < m.getColumnDimension(); j++) {
306 if (i == j) {
307 assertEquals(m.getEntry(i, j), Fraction.ONE);
308 } else {
309 assertEquals(m.getEntry(i, j), Fraction.ZERO);
310 }
311 }
312 }
313 }
314
315 public void testcreateFieldIdentityMatrix() {
316 checkIdentityFieldMatrix(MatrixUtils.createFieldIdentityMatrix(FractionField.getInstance(), 3));
317 checkIdentityFieldMatrix(MatrixUtils.createFieldIdentityMatrix(FractionField.getInstance(), 2));
318 checkIdentityFieldMatrix(MatrixUtils.createFieldIdentityMatrix(FractionField.getInstance(), 1));
319 try {
320 MatrixUtils.createRealIdentityMatrix(0);
321 } catch (IllegalArgumentException ex) {
322 // expected
323 }
324 }
325
326 public void testBigFractionConverter() {
327 BigFraction[][] bfData = {
328 { new BigFraction(1), new BigFraction(2), new BigFraction(3) },
329 { new BigFraction(2), new BigFraction(5), new BigFraction(3) },
330 { new BigFraction(1), new BigFraction(0), new BigFraction(8) }
331 };
332 FieldMatrix<BigFraction> m = new Array2DRowFieldMatrix<BigFraction>(bfData, false);
333 RealMatrix converted = MatrixUtils.bigFractionMatrixToRealMatrix(m);
334 RealMatrix reference = new Array2DRowRealMatrix(testData, false);
335 assertEquals(0.0, converted.subtract(reference).getNorm(), 0.0);
336 }
337
338 public void testFractionConverter() {
339 Fraction[][] fData = {
340 { new Fraction(1), new Fraction(2), new Fraction(3) },
341 { new Fraction(2), new Fraction(5), new Fraction(3) },
342 { new Fraction(1), new Fraction(0), new Fraction(8) }
343 };
344 FieldMatrix<Fraction> m = new Array2DRowFieldMatrix<Fraction>(fData, false);
345 RealMatrix converted = MatrixUtils.fractionMatrixToRealMatrix(m);
346 RealMatrix reference = new Array2DRowRealMatrix(testData, false);
347 assertEquals(0.0, converted.subtract(reference).getNorm(), 0.0);
348 }
349
350 public static final Fraction[][] asFraction(double[][] data) {
351 Fraction d[][] = new Fraction[data.length][];
352 try {
353 for (int i = 0; i < data.length; ++i) {
354 double[] dataI = data[i];
355 Fraction[] dI = new Fraction[dataI.length];
356 for (int j = 0; j < dataI.length; ++j) {
357 dI[j] = new Fraction(dataI[j]);
358 }
359 d[i] = dI;
360 }
361 } catch (FractionConversionException fce) {
362 fail(fce.getMessage());
363 }
364 return d;
365 }
366
367 public static final Fraction[] asFraction(double[] data) {
368 Fraction d[] = new Fraction[data.length];
369 try {
370 for (int i = 0; i < data.length; ++i) {
371 d[i] = new Fraction(data[i]);
372 }
373 } catch (FractionConversionException fce) {
374 fail(fce.getMessage());
375 }
376 return d;
377 }
378
379 /**
380 * Verifies that the matrix is an identity matrix
381 */
382 @Deprecated
383 protected void checkIdentityBigMatrix(BigMatrix m) {
384 for (int i = 0; i < m.getRowDimension(); i++) {
385 for (int j =0; j < m.getColumnDimension(); j++) {
386 if (i == j) {
387 assertEquals(m.getEntry(i, j), BigMatrixImpl.ONE);
388 } else {
389 assertEquals(m.getEntry(i, j), BigMatrixImpl.ZERO);
390 }
391 }
392 }
393 }
394
395 @Deprecated
396 public void testCreateBigIdentityMatrix() {
397 checkIdentityBigMatrix(MatrixUtils.createBigIdentityMatrix(3));
398 checkIdentityBigMatrix(MatrixUtils.createBigIdentityMatrix(2));
399 checkIdentityBigMatrix(MatrixUtils.createBigIdentityMatrix(1));
400 try {
401 MatrixUtils.createRealIdentityMatrix(0);
402 } catch (IllegalArgumentException ex) {
403 // expected
404 }
405 }
406
407 }
408