    1   /*
    2    * Copyright 2004 The Apache Software Foundation.
    3    *
    4    * Licensed under the Apache License, Version 2.0 (the "License");
    5    * you may not use this file except in compliance with the License.
    6    * You may obtain a copy of the License at
    7    *
    8    *      http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  package org.apache.commons.math.linear;
    17
    18  import java.math.BigDecimal;
    19  import junit.framework.Test;
    20  import junit.framework.TestCase;
    21  import junit.framework.TestSuite;
    22
    23  /***
    24   * Test cases for the {@link MatrixUtils} class.
    25   *
    26   * @version $Revision: 1.3 $ $Date: 2004/10/28 03:02:34 $
    27   */
    28
    29  public final class MatrixUtilsTest extends TestCase {
    30
    31      protected double[][] testData = { {1d,2d,3d}, {2d,5d,3d}, {1d,0d,8d} };
    32      protected double[][] nullMatrix = null;
    33      protected double[] row = {1,2,3};
    34      protected BigDecimal[] bigRow =
    35          {new BigDecimal(1),new BigDecimal(2),new BigDecimal(3)};
    36      protected String[] stringRow = {"1", "2", "3"};
    37      protected double[][] rowMatrix = {{1,2,3}};
    38      protected BigDecimal[][] bigRowMatrix =
    39          {{new BigDecimal(1), new BigDecimal(2), new BigDecimal(3)}};
    40      protected String[][] stringRowMatrix = {{"1", "2", "3"}};
    41      protected double[] col = {0,4,6};
    42      protected BigDecimal[] bigCol =
    43          {new BigDecimal(0),new BigDecimal(4),new BigDecimal(6)};
    44      protected String[] stringCol = {"0","4","6"};
    45      protected double[] nullDoubleArray = null;
    46      protected double[][] colMatrix = {{0},{4},{6}};
    47      protected BigDecimal[][] bigColMatrix =
    48          {{new BigDecimal(0)},{new BigDecimal(4)},{new BigDecimal(6)}};
    49      protected String[][] stringColMatrix = {{"0"}, {"4"}, {"6"}};
    50
    51      public MatrixUtilsTest(String name) {
    52          super(name);
    53      }
    54
    55      public void setUp() {
    56      }
    57
    58      public static Test suite() {
    59          TestSuite suite = new TestSuite(MatrixUtilsTest.class);
    60          suite.setName("MatrixUtils Tests");
    61          return suite;
    62      }
    63
    64      public void testCreateRealMatrix() {
    65          assertEquals(new RealMatrixImpl(testData),
    66                  MatrixUtils.createRealMatrix(testData));
    67          try {
    68              MatrixUtils.createRealMatrix(new double[][] {{1}, {1,2}});  // ragged
    69              fail("Expecting IllegalArgumentException");
    70          } catch (IllegalArgumentException ex) {
    71              // expected
    72          }
    73          try {
    74              MatrixUtils.createRealMatrix(new double[][] {{}, {}});  // no columns
    75              fail("Expecting IllegalArgumentException");
    76          } catch (IllegalArgumentException ex) {
    77              // expected
    78          }
    79          try {
    80              MatrixUtils.createRealMatrix(null);  // null
    81              fail("Expecting NullPointerException");
    82          } catch (NullPointerException ex) {
    83              // expected
    84          }
    85      }
    86
    87      public void testCreateBigMatrix() {
    88          assertEquals(new BigMatrixImpl(testData),
    89                  MatrixUtils.createBigMatrix(testData));
    90          assertEquals(new BigMatrixImpl(bigColMatrix),
    91                  MatrixUtils.createBigMatrix(bigColMatrix));
    92          assertEquals(new BigMatrixImpl(stringColMatrix),
    93                  MatrixUtils.createBigMatrix(stringColMatrix));
    94          try {
    95              MatrixUtils.createBigMatrix(new double[][] {{1}, {1,2}});  // ragged
    96              fail("Expecting IllegalArgumentException");
    97          } catch (IllegalArgumentException ex) {
    98              // expected
    99          }
    100         try {
    101             MatrixUtils.createBigMatrix(new double[][] {{}, {}});  // no columns
    102             fail("Expecting IllegalArgumentException");
    103         } catch (IllegalArgumentException ex) {
    104             // expected
    105         }
    106         try {
    107             MatrixUtils.createBigMatrix(nullMatrix);  // null
    108             fail("Expecting NullPointerException");
    109         } catch (NullPointerException ex) {
    110             // expected
    111         }
    112     }
    113
    114     public void testCreateRowRealMatrix() {
    115         assertEquals((RealMatrixImpl) MatrixUtils.createRowRealMatrix(row),
    116                new RealMatrixImpl(rowMatrix));
    117         try {
    118             MatrixUtils.createRowRealMatrix(new double[] {});  // empty
    119             fail("Expecting IllegalArgumentException");
    120         } catch (IllegalArgumentException ex) {
    121             // expected
    122         }
    123         try {
    124             MatrixUtils.createRowRealMatrix(null);  // null
    125             fail("Expecting NullPointerException");
    126         } catch (NullPointerException ex) {
    127             // expected
    128         }
    129     }
    130
    131     public void testCreateRowBigMatrix() {
    132         assertEquals((BigMatrixImpl) MatrixUtils.createRowBigMatrix(row),
    133                 new BigMatrixImpl(rowMatrix));
    134         assertEquals((BigMatrixImpl) MatrixUtils.createRowBigMatrix(bigRow),
    135                 new BigMatrixImpl(bigRowMatrix));
    136         assertEquals((BigMatrixImpl) MatrixUtils.createRowBigMatrix(stringRow),
    137                 new BigMatrixImpl(stringRowMatrix));
    138         try {
    139             MatrixUtils.createRowBigMatrix(new double[] {});  // empty
    140             fail("Expecting IllegalArgumentException");
    141         } catch (IllegalArgumentException ex) {
    142             // expected
    143         }
    144         try {
    145             MatrixUtils.createRowBigMatrix(nullDoubleArray);  // null
    146             fail("Expecting NullPointerException");
    147         } catch (NullPointerException ex) {
    148             // expected
    149         }
    150     }
    151
    152     public void testCreateColumnRealMatrix() {
    153         assertEquals((RealMatrixImpl) MatrixUtils.createColumnRealMatrix(col),
    154                 new RealMatrixImpl(colMatrix));
    155         try {
    156             MatrixUtils.createColumnRealMatrix(new double[] {});  // empty
    157             fail("Expecting IllegalArgumentException");
    158         } catch (IllegalArgumentException ex) {
    159             // expected
    160         }
    161         try {
    162             MatrixUtils.createColumnRealMatrix(null);  // null
    163             fail("Expecting NullPointerException");
    164         } catch (NullPointerException ex) {
    165             // expected
    166         }
    167     }
    168
    169     public void testCreateColumnBigMatrix() {
    170         assertEquals((BigMatrixImpl) MatrixUtils.createColumnBigMatrix(col),
    171                 new BigMatrixImpl(colMatrix));
    172         assertEquals((BigMatrixImpl) MatrixUtils.createColumnBigMatrix(bigCol),
    173                 new BigMatrixImpl(bigColMatrix));
    174         assertEquals((BigMatrixImpl) MatrixUtils.createColumnBigMatrix(stringCol),
    175                 new BigMatrixImpl(stringColMatrix));
    176
    177         try {
    178             MatrixUtils.createColumnBigMatrix(new double[] {});  // empty
    179             fail("Expecting IllegalArgumentException");
    180         } catch (IllegalArgumentException ex) {
    181             // expected
    182         }
    183         try {
    184             MatrixUtils.createColumnBigMatrix(nullDoubleArray);  // null
    185             fail("Expecting NullPointerException");
    186         } catch (NullPointerException ex) {
    187             // expected
    188         }
    189     }
    190
    191 }
    192