View Javadoc

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  
17  package org.apache.commons.math.linear;
18  
19  import java.math.BigDecimal;
20  
21  /***
22   * A collection of static methods that operate on or return matrices.
23   * 
24   * @version $Revision: 1.2 $ $Date: 2004/10/25 05:36:15 $
25   */
26  public class MatrixUtils {
27  
28      /***
29       * Default constructor.  Package scope to prevent unwanted instantiation. 
30       */
31      public MatrixUtils() {
32          super();
33      }
34      
35      /***
36       * Returns a {@link RealMatrix} whose entries are the the values in the
37       * the input array.  The input array is copied, not referenced.
38       * 
39       * @param data input array
40       * @return  RealMatrix containing the values of the array
41       * @throws IllegalArgumentException if <code>data</code> is not rectangular
42       *  (not all rows have the same length) or empty
43       * @throws NullPointerException if data is null
44       */
45      public static RealMatrix createRealMatrix(double[][] data) {
46          return new RealMatrixImpl(data);
47      }
48      
49      /***
50       * Returns a {@link BigMatrix} whose entries are the the values in the
51       * the input array.  The input array is copied, not referenced.
52       * 
53       * @param data input array
54       * @return  RealMatrix containing the values of the array
55       * @throws IllegalArgumentException if <code>data</code> is not rectangular
56       *  (not all rows have the same length) or empty
57       * @throws NullPointerException if data is null
58       */
59      public static BigMatrix createBigMatrix(double[][] data) {
60          return new BigMatrixImpl(data);
61      }
62      
63      /***
64       * Returns a {@link BigMatrix} whose entries are the the values in the
65       * the input array.  The input array is copied, not referenced.
66       * 
67       * @param data input array
68       * @return  RealMatrix containing the values of the array
69       * @throws IllegalArgumentException if <code>data</code> is not rectangular
70       *  (not all rows have the same length) or empty
71       * @throws NullPointerException if data is null
72       */
73      public static BigMatrix createBigMatrix(BigDecimal[][] data) {
74          return new BigMatrixImpl(data);
75      }
76      
77      /***
78       * Returns a {@link BigMatrix} whose entries are the the values in the
79       * the input array.  The input array is copied, not referenced.
80       * 
81       * @param data input array
82       * @return  RealMatrix containing the values of the array
83       * @throws IllegalArgumentException if <code>data</code> is not rectangular
84       *  (not all rows have the same length) or empty
85       * @throws NullPointerException if data is null
86       */
87      public static BigMatrix createBigMatrix(String[][] data) {
88          return new BigMatrixImpl(data);
89      }
90      
91      /***
92       * Creates a row {@link RealMatrix} using the data from the input
93       * array. 
94       * 
95       * @param rowData the input row data
96       * @return a 1 x rowData.length RealMatrix
97       * @throws IllegalArgumentException if <code>rowData</code> is empty
98       * @throws NullPointerException if <code>rowData</code>is null
99       */
100     public static RealMatrix createRowRealMatrix(double[] rowData) {
101         int nCols = rowData.length;
102         double[][] data = new double[1][nCols];
103         System.arraycopy(rowData, 0, data[0], 0, nCols);
104         return new RealMatrixImpl(data);
105     }
106     
107     /***
108      * Creates a row {@link BigMatrix} using the data from the input
109      * array. 
110      * 
111      * @param rowData the input row data
112      * @return a 1 x rowData.length BigMatrix
113      * @throws IllegalArgumentException if <code>rowData</code> is empty
114      * @throws NullPointerException if <code>rowData</code>is null
115      */
116     public static BigMatrix createRowBigMatrix(double[] rowData) {
117         int nCols = rowData.length;
118         double[][] data = new double[1][nCols];
119         System.arraycopy(rowData, 0, data[0], 0, nCols);
120         return new BigMatrixImpl(data);
121     }
122     
123     /***
124      * Creates a row {@link BigMatrix} using the data from the input
125      * array. 
126      * 
127      * @param rowData the input row data
128      * @return a 1 x rowData.length BigMatrix
129      * @throws IllegalArgumentException if <code>rowData</code> is empty
130      * @throws NullPointerException if <code>rowData</code>is null
131      */
132     public static BigMatrix createRowBigMatrix(BigDecimal[] rowData) {
133         int nCols = rowData.length;
134         BigDecimal[][] data = new BigDecimal[1][nCols];
135         System.arraycopy(rowData, 0, data[0], 0, nCols);
136         return new BigMatrixImpl(data);
137     }
138     
139     /***
140      * Creates a row {@link BigMatrix} using the data from the input
141      * array. 
142      * 
143      * @param rowData the input row data
144      * @return a 1 x rowData.length BigMatrix
145      * @throws IllegalArgumentException if <code>rowData</code> is empty
146      * @throws NullPointerException if <code>rowData</code>is null
147      */
148     public static BigMatrix createRowBigMatrix(String[] rowData) {
149         int nCols = rowData.length;
150         String[][] data = new String[1][nCols];
151         System.arraycopy(rowData, 0, data[0], 0, nCols);
152         return new BigMatrixImpl(data);
153     }
154     
155     /***
156      * Creates a column {@link RealMatrix} using the data from the input
157      * array.
158      * 
159      * @param columnData  the input column data
160      * @return a columnData x 1 RealMatrix
161      * @throws IllegalArgumentException if <code>columnData</code> is empty
162      * @throws NullPointerException if <code>columnData</code>is null
163      */
164     public static RealMatrix createColumnRealMatrix(double[] columnData) {
165         int nRows = columnData.length;
166         double[][] data = new double[nRows][1];
167         for (int row = 0; row < nRows; row++) {
168             data[row][0] = columnData[row];
169         }
170         return new RealMatrixImpl(data);
171     }
172     
173     /***
174      * Creates a column {@link BigMatrix} using the data from the input
175      * array.
176      * 
177      * @param columnData  the input column data
178      * @return a columnData x 1 BigMatrix
179      * @throws IllegalArgumentException if <code>columnData</code> is empty
180      * @throws NullPointerException if <code>columnData</code>is null
181      */
182     public static BigMatrix createColumnBigMatrix(double[] columnData) {
183         int nRows = columnData.length;
184         double[][] data = new double[nRows][1];
185         for (int row = 0; row < nRows; row++) {
186             data[row][0] = columnData[row];
187         }
188         return new BigMatrixImpl(data);
189     }
190     
191     /***
192      * Creates a column {@link BigMatrix} using the data from the input
193      * array.
194      * 
195      * @param columnData  the input column data
196      * @return a columnData x 1 BigMatrix
197      * @throws IllegalArgumentException if <code>columnData</code> is empty
198      * @throws NullPointerException if <code>columnData</code>is null
199      */
200     public static BigMatrix createColumnBigMatrix(BigDecimal[] columnData) {
201         int nRows = columnData.length;
202         BigDecimal[][] data = new BigDecimal[nRows][1];
203         for (int row = 0; row < nRows; row++) {
204             data[row][0] = columnData[row];
205         }
206         return new BigMatrixImpl(data);
207     }
208     
209     /***
210      * Creates a column {@link BigMatrix} using the data from the input
211      * array.
212      * 
213      * @param columnData  the input column data
214      * @return a columnData x 1 BigMatrix
215      * @throws IllegalArgumentException if <code>columnData</code> is empty
216      * @throws NullPointerException if <code>columnData</code>is null
217      */
218     public static BigMatrix createColumnBigMatrix(String[] columnData) {
219         int nRows = columnData.length;
220         String[][] data = new String[nRows][1];
221         for (int row = 0; row < nRows; row++) {
222             data[row][0] = columnData[row];
223         }
224         return new BigMatrixImpl(data);
225     }
226     
227 }
228