Source code: jmat/MatlabSyntax.java
1 package jmat;
2
3 import jmat.data.*;
4
5 import jmat.function.*;
6
7 import jmat.io.data.*;
8
9 import jmat.io.gui.*;
10
11
12 /**
13 * <p>Description : Enables an easy to use Matlab-like syntax for invokation of main features.</p>
14 * <p>Copyright : GPL</p>
15 * @author Yann RICHET
16 * @version 1.0
17 */
18 public class MatlabSyntax
19 {
20 //~ Methods ////////////////////////////////////////////////////////////////
21
22 /** Set a column to an internal one-dimensional Column.
23 @param A Matrix.
24 @param c Column index
25 @param B Column-matrix
26 */
27 public static void setColumn(Matrix A, int c, Matrix B)
28 {
29 A.setColumn(c - 1, B);
30 }
31
32 /** Copy an internal one-dimensional array from a column.
33 @param A Matrix.
34 @param c Column index
35 @return one-dimensional array copy of matrix elements.
36 */
37
38 /*M
39 <syntax>
40 <matlab>X = A(:,c);</matlab>
41 <java>X = getColumn(A,c);</java>
42 </syntax>
43 */
44 public static Matrix getColumn(Matrix A, int c)
45 {
46 return A.getColumn(c - 1);
47 }
48
49 /** Copy an internal one-dimensional array from a row.
50 @param A Matrix.
51 @param l Row index
52 @param B Row-matrix
53 */
54
55 /*M
56 <syntax>
57 <matlab>A(l,:) = B;</matlab>
58 <java>setRow(A,l,B);</java>
59 </syntax>
60 */
61 public static void setRow(Matrix A, int l, Matrix B)
62 {
63 A.setRow(l - 1, B);
64 }
65
66 /** Copy an internal one-dimensional array from a row.
67 @param A Matrix.
68 @param l Row index
69 @return one-dimensional array copy of matrix elements.
70 */
71
72 /*M
73 <syntax>
74 <matlab>X = A(i,:);</matlab>
75 <java>X = getRow(A,i);</java>
76 </syntax>
77 */
78 public static Matrix getRow(Matrix A, int l)
79 {
80 return A.getRow(l - 1);
81 }
82
83 /**Element-by-element inverse
84 @param A Matrix.
85 @return |A|
86 */
87
88 /*M
89 <syntax>
90 <matlab>X = abs(A);</matlab>
91 <java>X = abs(A);</java>
92 </syntax>
93 */
94 public static Matrix abs(Matrix A)
95 {
96 return A.ebeAbs();
97 }
98
99 /** Cholesky Decomposition
100 @param A Matrix.
101 @return L
102 */
103
104 /*M
105 <syntax>
106 <matlab>L = chol(A);</matlab>
107 <java>L = chol(A);</java>
108 </syntax>
109 */
110 public static Matrix chol(Matrix A)
111 {
112 return A.chol().getL();
113 }
114
115 /** Matrix condition (2 norm)
116 @param A Matrix.
117 @return ratio of largest to smallest singular value.
118 */
119
120 /*M
121 <syntax>
122 <matlab>d = cond(A);</matlab>
123 <java>d = cond(A);</java>
124 </syntax>
125 */
126 public static double cond(Matrix A)
127 {
128 return A.cond();
129 }
130
131 /** Generate a correlation matrix.
132 @param A Matrix.
133 @return An m-by-m matrix.
134 */
135
136 /*M
137 <syntax>
138 <matlab>X = corrcoef(A);</matlab>
139 <java>X = corrcoef(A);</java>
140 </syntax>
141 */
142 public static Matrix corrcoef(Matrix A)
143 {
144 return new RandomMatrix(A).cor();
145 }
146
147 /**Element-by-element cosinus
148 @param A Matrix.
149 @return cos.(A)
150 */
151
152 /*M
153 <syntax>
154 <matlab>X = cos(A);</matlab>
155 <java>X = cos(A);</java>
156 </syntax>
157 */
158 public static Matrix cos(Matrix A)
159 {
160 return A.ebeCos();
161 }
162
163 /** Generate a covariance matrix.
164 @param A Matrix.
165 @return An m-by-m matrix.
166 */
167
168 /*M
169 <syntax>
170 <matlab>X = cov(A);</matlab>
171 <java>X = cov(A);</java>
172 </syntax>
173 */
174 public static Matrix cov(Matrix A)
175 {
176 return new RandomMatrix(A).cov();
177 }
178
179 /** Matrix determinant
180 @param A Matrix.
181 @return determinant
182 */
183
184 /*M
185 <syntax>
186 <matlab>d = det(A);</matlab>
187 <java>d = det(A);</java>
188 </syntax>
189 */
190 public static double det(Matrix A)
191 {
192 return A.det();
193 }
194
195 /** Matrix diagonal extraction.
196 @param A Matrix.
197 @return An d*1 Matrix of diagonal elements, d = min(m,n).
198 */
199
200 /*M
201 <syntax>
202 <matlab>X = diag(A);</matlab>
203 <java>X = diag(A);</java>
204 </syntax>
205 */
206 public static Matrix diag(Matrix A)
207 {
208 return A.diag();
209 }
210
211 /** Matrix diagonal extraction.
212 @param A Matrix.
213 @param num diagonal number.
214 @return Matrix of the n-th diagonal elements.
215 */
216
217 /*M
218 <syntax>
219 <matlab>X = diag(A,n);</matlab>
220 <java>X = diag(A,n);</java>
221 </syntax>
222 */
223 public static Matrix diag(Matrix A, int num)
224 {
225 return A.diag(num);
226 }
227
228 /////////////////////////////////////////////////////////
229 //Matrix io methods, in panels, frames or command line.//
230 /////////////////////////////////////////////////////////
231
232 /** Print the Matrix in the Command Line.
233 @param A Matrix.
234 */
235
236 /*M
237 <syntax>
238 <matlab>disp(A);</matlab>
239 <java>disp(A);</java>
240 </syntax>
241 */
242 public static void disp(Matrix A)
243 {
244 A.toCommandLine("");
245 }
246
247 /** Print the Matrix in the Command Line.
248 @param text String.
249 */
250
251 /*M
252 <syntax>
253 <matlab>disp('abcdef');</matlab>
254 <java>disp('abcdef');</java>
255 </syntax>
256 */
257 public static void disp(String text)
258 {
259 System.out.println(text);
260 }
261
262 /** Divide a matrix by a scalar, C = A/s
263 @param A Matrix.
264 @param s scalar
265 @return A/s
266 */
267
268 /*M
269 <syntax>
270 <matlab>X = A/s;</matlab>
271 <java>X = divide(A,s);</java>
272 </syntax>
273 */
274 public static Matrix divide(Matrix A, double s)
275 {
276 return A.divide(s);
277 }
278
279 /** Linear algebraic matrix division, A / B
280 @param A Matrix.
281 @param B another matrix
282 @return Matrix division, A / B
283 */
284
285 /*M
286 <syntax>
287 <matlab>X = A/B;</matlab>
288 <java>X = divide(A,B);</java>
289 </syntax>
290 */
291 public static Matrix divide(Matrix A, Matrix B)
292 {
293 return A.divide(B);
294 }
295
296 /** Element-by-element right division, C = A./B
297 @param A Matrix.
298 @param B another matrix
299 @return A./B
300 */
301
302 /*M
303 <syntax>
304 <matlab>X = A./B;</matlab>
305 <java>X = ebeDivide(A,B);</java>
306 </syntax>
307 */
308 public static Matrix ebeDivide(Matrix A, Matrix B)
309 {
310 return A.ebeDivide(B);
311 }
312
313 /////////////////////////
314 //Functions for Matrix.//
315 /////////////////////////
316
317 /** Element-by-element multiplication, C = A.*B
318 @param A Matrix.
319 @param B another matrix
320 @return A.*B
321 */
322
323 /*M
324 <syntax>
325 <matlab>X = A.*B;</matlab>
326 <java>X = ebeTimes(A,B);</java>
327 </syntax>
328 */
329 public static Matrix ebeTimes(Matrix A, Matrix B)
330 {
331 return A.ebeTimes(B);
332 }
333
334 /** Eigenvalue Decomposition
335 @param A Matrix.
336 @return D
337 */
338
339 /*M
340 <syntax>
341 <matlab>[V,D] = eig(A);</matlab>
342 <java>D = eig_D(A);</java>
343 </syntax>
344 */
345 public static Matrix eig_D(Matrix A)
346 {
347 return A.eig().getD();
348 }
349
350 /** Eigenvalue Decomposition
351 @param A Matrix.
352 @return V
353 */
354
355 /*M
356 <syntax>
357 <matlab>[V,D] = eig(A);</matlab>
358 <java>V = eig_V(A);</java>
359 </syntax>
360 */
361 public static Matrix eig_V(Matrix A)
362 {
363 return A.eig().getV();
364 }
365
366 /**Element-by-element exponential
367 @param A Matrix.
368 @return exp.(A)
369 */
370
371 /*M
372 <syntax>
373 <matlab>X = exp(A);</matlab>
374 <java>X = exp(A);</java>
375 </syntax>
376 */
377 public static Matrix exp(Matrix A)
378 {
379 return A.ebeExp();
380 }
381
382 /** Construct an m-by-n matrix of random numbers from an exponantial random variable.
383 @param m Number of rows.
384 @param n Number of columns.
385 @param mu Parmaeter of the exponential random variable.
386 @return A RandomMatrix.
387 */
388
389 /*M
390 <syntax>
391 <matlab>X = exprnd(mu,m,n);</matlab>
392 <java>X = expRnd(mu,m,n);</java>
393 </syntax>
394 */
395 public static RandomMatrix expRnd(double mu, int m, int n)
396 {
397 return RandomMatrix.exponential(m, n, mu);
398 }
399
400 /** Generate identity matrix
401 @param m Number of rows.
402 @param n Number of colums.
403 @return An m-by-n matrix with ones on the diagonal and zeros elsewhere.
404 */
405
406 /*M
407 <syntax>
408 <matlab>X = eye(m,n);</matlab>
409 <java>X = eye(m,n);</java>
410 </syntax>
411 */
412 public static Matrix eye(int m, int n)
413 {
414 return Matrix.identity(m, n);
415 }
416
417 /** Find elements verifying a boolean test
418 @param A Matrix.
419 @param test Test to apply: < > =...
420 @param e Element (value) to compare
421 @return A list of indices where this element is found.
422 */
423
424 /*M
425 <syntax>
426 <matlab>[I,J] = find(A<3);</matlab>
427 <java>IJ = find(A,'<',3);</java>
428 </syntax>
429 */
430 public static Matrix find(Matrix A, String test, double e)
431 {
432 int[][] I = A.find(test, e);
433 Matrix X = new Matrix(I.length, 2);
434
435 for (int i = 0; i < I.length; i++)
436 {
437 X.set(i, 0, I[i][0] + 1);
438 X.set(i, 1, I[i][1] + 1);
439 }
440
441 return X;
442 }
443
444 ////////////////////////////////////////////////////////////
445 //Basic and advanced Get methods for matrix and submatrix.//
446 ////////////////////////////////////////////////////////////
447
448 /** Get a single element.
449 @param A Matrix.
450 @param i Row index.
451 @param j Column index.
452 @return A(i,j)
453 @exception ArrayIndexOutOfBoundsException
454 */
455
456 /*M
457 <syntax>
458 <matlab>d = A(i,j);</matlab>
459 <java>d = get(A,i,j);</java>
460 </syntax>
461 */
462 public static double get(Matrix A, int i, int j)
463 {
464 return A.get(i - 1, j - 1);
465 }
466
467 /** Get a submatrix.
468 @param A Matrix.
469 @param i0 Initial row index
470 @param i1 Final row index
471 @param j0 Initial column index
472 @param j1 Final column index
473 @return A(i0:i1,j0:j1)
474 */
475
476 /*M
477 <syntax>
478 <matlab>d = A(i0:i1,j0:j1);</matlab>
479 <java>d = get(A,i0,i1,j0,j1);</java>
480 </syntax>
481 */
482 public static Matrix get(Matrix A, int i0, int i1, int j0, int j1)
483 {
484 return A.getMatrix(i0 - 1, i1 - 1, j0 - 1, j1 - 1);
485 }
486
487 /** Plot the Matrix in a JFrame
488 @param X Matrix.
489 @param n Number of slices.
490 @return A MatrixPlot2D (extends a Swing JPanel)
491 */
492
493 /*M
494 <syntax>
495 <matlab>figure;hist(X,20);</matlab>
496 <java>hist(X,20);</java>
497 </syntax>
498 */
499 public static Plot2D hist(Matrix X, int n)
500 {
501 return new RandomMatrix(X).toFrameHist2D("", n);
502 }
503
504 /** Plot the Matrix in a JFrame
505 @param X Matrix.
506 @param n Number of slices.
507 @param title Title of the JFrame.
508 @return A MatrixPlot2D (extends a Swing JPanel)
509 */
510
511 /*M
512 <syntax>
513 <matlab>figure(title);hist(X,20);</matlab>
514 <java>hist(title,X,20);</java>
515 </syntax>
516 */
517 public static Plot2D hist(String title, Matrix X, int n)
518 {
519 return new RandomMatrix(X).toFrameHist2D(title, n);
520 }
521
522 /** Generate a matrix with a constant pitch beetwen each row
523 @param m Number of rows.
524 @param n Number of colums.
525 @param begin begining value to increment.
526 @param pitch pitch to add.
527 @return An m-by-n matrix.
528 */
529 public static Matrix inc(int m, int n, double begin, double pitch)
530 {
531 return Matrix.increment(m, n, begin, pitch);
532 }
533
534 /** Generate a matrix with a constant pitch beetwen each row
535 @param m Number of rows.
536 @param n Number of colums.
537 @return An m-by-n matrix.
538 */
539 public static Matrix inc(int m, int n)
540 {
541 return Matrix.increment(m, n, 1, n);
542 }
543
544 /** Matrix inverse or pseudoinverse
545 @param A Matrix.
546 @return inverse(A) if A is square, pseudoinverse otherwise.
547 */
548
549 /*M
550 <syntax>
551 <matlab>X = inv(A);</matlab>
552 <java>X = inv(A);</java>
553 </syntax>
554 */
555 public static Matrix inv(Matrix A)
556 {
557 return A.inverse();
558 }
559
560 /** Load the Matrix from an ASCII file.
561 @param fileName filename of the file to load.
562 @return A matrix.
563 */
564
565 /*M
566 <syntax>
567 <matlab>X = load('A.dat');</matlab>
568 <java>X = load('A.dat');</java>
569 </syntax>
570 */
571 public static Matrix load(String fileName)
572 {
573 return Matrix.fromFile(fileName);
574 }
575
576 /**Element-by-element neperian logarithm
577 @param A Matrix.
578 @return log.(A)
579 */
580
581 /*M
582 <syntax>
583 <matlab>X = log(A);</matlab>
584 <java>X = log(A);</java>
585 </syntax>
586 */
587 public static Matrix log(Matrix A)
588 {
589 return A.ebeLog();
590 }
591
592 ///////////////////////////////////////////////
593 //Advanced Decompositions methods for Matrix.//
594 ///////////////////////////////////////////////
595
596 /** LU Decomposition
597 @param A Matrix.
598 @return L
599 */
600
601 /*M
602 <syntax>
603 <matlab>[L,U,P] = lu(A);</matlab>
604 <java>L = lu_L(A);</java>
605 </syntax>
606 */
607 public static Matrix lu_L(Matrix A)
608 {
609 return A.lu().getL();
610 }
611
612 /** LU Decomposition
613 @param A Matrix.
614 @return P
615 */
616
617 /*M
618 <syntax>
619 <matlab>[L,U,P] = lu(A);</matlab>
620 <java>P = lu_P(A);</java>
621 </syntax>
622 */
623 public static Matrix lu_P(Matrix A)
624 {
625 return A.lu().getP();
626 }
627
628 /** LU Decomposition
629 @param A Matrix.
630 @return U
631 */
632
633 /*M
634 <syntax>
635 <matlab>[L,U,P] = lu(A);</matlab>
636 <java>U = lu_U(A);</java>
637 </syntax>
638 */
639 public static Matrix lu_U(Matrix A)
640 {
641 return A.lu().getU();
642 }
643
644 /** Construct an m-by-n constant matrix.
645 @param m Number of rows.
646 @param n Number of colums.
647 @param s Fill the matrix with this scalar value.
648 @return An m-by-n matrix of scalar.
649 */
650 public static Matrix matrix(int m, int n, double s)
651 {
652 return new Matrix(m, n, s);
653 }
654
655 /** Construct a matrix from a 2D-array.
656 @param B Two-dimensional array of doubles.
657 @exception IllegalArgumentException All rows must have the same length
658 @return An m-by-n matrix.
659 */
660 public static Matrix matrix(double[][] B)
661 {
662 return new Matrix(B);
663 }
664
665 /** Generate a row matrix, each column contents the maximum value of the columns.
666 @param A Matrix.
667 @return An 1-by-n matrix.
668 */
669
670 /*M
671 <syntax>
672 <matlab>X = max(A);</matlab>
673 <java>X = max(A);</java>
674 </syntax>
675 */
676 public static Matrix max(Matrix A)
677 {
678 return A.max();
679 }
680
681 /** Generate a row matrix, each column contents the mean value of the columns.
682 @param A Matrix.
683 @return An 1-by-n matrix.
684 */
685
686 /*M
687 <syntax>
688 <matlab>X = mean(A);</matlab>
689 <java>X = mean(A);</java>
690 </syntax>
691 */
692 public static Matrix mean(Matrix A)
693 {
694 return new RandomMatrix(A).mean();
695 }
696
697 /** Generate a matrix from other matrix.
698 @param A 1st Matrix to merge.
699 @param B 2nd Matrix to merge.
700 @param n dimension to merge.
701 @return An m1+m2+...-by-n matrix.
702 */
703
704 /*M
705 <syntax>
706 <matlab>X = [A,B];</matlab>
707 <java>X = merge(A,B,2);</java>
708 </syntax>
709 */
710 public static Matrix merge(Matrix A, Matrix B, int n)
711 {
712 if (n == 1)
713 {
714 return A.mergeRows(B);
715 }
716 else if (n == 2)
717 {
718 return A.mergeColumns(B);
719 }
720 else
721 {
722 return A;
723 }
724 }
725
726 /** Generate a row matrix, each column contents the minimum value of the columns.
727 @param A Matrix.
728 @return An 1-by-n matrix.
729 */
730
731 /*M
732 <syntax>
733 <matlab>X = min(A);</matlab>
734 <java>X = min(A);</java>
735 </syntax>
736 */
737 public static Matrix min(Matrix A)
738 {
739 return A.min();
740 }
741
742 /** C = A - B
743 @param A Matrix.
744 @param B another matrix
745 @return A - B
746 */
747
748 /*M
749 <syntax>
750 <matlab>X = A-B;</matlab>
751 <java>X = minus(A,B);</java>
752 </syntax>
753 */
754 public static Matrix minus(Matrix A, Matrix B)
755 {
756 return A.minus(B);
757 }
758
759 ////////////////////////////////////////
760 //Norms and characteristics of Matrix.//
761 ////////////////////////////////////////
762
763 /** Norm
764 @param A Matrix.
765 @param n Norm indice.
766 @return norm value.
767 */
768
769 /*M
770 <syntax>
771 <matlab>d = norm(A,2);</matlab>
772 <java>d = norm(A,'2');</java>
773 </syntax>
774 */
775 public static double norm(Matrix A, String n)
776 {
777 if (n.equals("1"))
778 {
779 return A.norm1();
780 }
781 else if (n.equals("2"))
782 {
783 return A.norm2();
784 }
785 else if (n.equals("Inf"))
786 {
787 return A.normInf();
788 }
789 else if (n.equals("Fro"))
790 {
791 return A.normF();
792 }
793 else
794 {
795 return Double.NaN;
796 }
797 }
798
799 /** Construct an m-by-n matrix of random numbers from an normal random variable.
800 @param m Number of rows.
801 @param n Number of columns.
802 @param mu Mean of the normal random variable.
803 @param sigma Variance of the normal random variable.
804 @return A RandomMatrix.
805 */
806
807 /*M
808 <syntax>
809 <matlab>X = normrnd(mu,sigma,m,n);</matlab>
810 <java>X = normRnd(mu,sigma,m,n);</java>
811 </syntax>
812 */
813 public static RandomMatrix normRnd(double mu, double sigma, int m, int n)
814 {
815 return RandomMatrix.normal(m, n, mu, sigma);
816 }
817
818 /** Construct an m-by-n matrix of ones.
819 @param m Number of rows.
820 @param n Number of colums.
821 @return An m-by-n matrix of ones.
822 */
823
824 /*M
825 <syntax>
826 <matlab>X = ones(m,n);</matlab>
827 <java>X = ones(m,n);</java>
828 </syntax>
829 */
830 public static Matrix ones(int m, int n)
831 {
832 return new Matrix(m, n, 1);
833 }
834
835 /** Plot the Matrix in a JFrame
836 @param X Matrix.
837 @param Y Matrix.
838 @return A MatrixPlot2D (extends a Swing JPanel)
839 */
840
841 /*M
842 <syntax>
843 <matlab>figure;plot(X,Y,'.');</matlab>
844 <java>plot(X,Y);</java>
845 </syntax>
846 */
847 public static Plot2D plot(Matrix X, Matrix Y)
848 {
849 return Y.toFramePlot2D("", X);
850 }
851
852 /** Plot the Matrix in a JFrame
853 @param title Title of the JFrame.
854 @param X Matrix.
855 @param Y Matrix.
856 @return A MatrixPlot2D (extends a Swing JPanel)
857 */
858
859 /*M
860 <syntax>
861 <matlab>figure(title);plot(X,Y,'.');</matlab>
862 <java>plot(title,X,Y);</java>
863 </syntax>
864 */
865 public static Plot2D plot(String title, Matrix X, Matrix Y)
866 {
867 return Y.toFramePlot2D(title, X);
868 }
869
870 /** Plot the Matrix in a Window in a JFrame
871 @param X Matrix
872 @param Y Matrix
873 @param Z Matrix
874 @return A MatrixPlot3D (extends a Swing JPanel)
875 */
876
877 /*M
878 <syntax>
879 <matlab>figure;plot3(X,Y,Z,'.');</matlab>
880 <java>plot3(X,Y,Z);</java>
881 </syntax>
882 */
883 public static Plot3D plot3(Matrix X, Matrix Y, Matrix Z)
884 {
885 return Z.toFramePlot3D("", X, Y);
886 }
887
888 /** Plot the Matrix in a Window in a JFrame
889 @param title Title of the JFrame.
890 @param X Matrix
891 @param Y Matrix
892 @param Z Matrix
893 @return A MatrixPlot3D (extends a Swing JPanel)
894 */
895
896 /*M
897 <syntax>
898 <matlab>figure(title);plot3(X,Y,Z,'.');</matlab>
899 <java>plot3(title,X,Y,Z);</java>
900 </syntax>
901 */
902 public static Plot3D plot3(String title, Matrix X, Matrix Y, Matrix Z)
903 {
904 return Z.toFramePlot3D(title, X, Y);
905 }
906
907 /** C = A + B
908 @param A Matrix.
909 @param B another matrix
910 @return A + B
911 */
912
913 /*M
914 <syntax>
915 <matlab>X = A+B;</matlab>
916 <java>X = plus(A,B);</java>
917 </syntax>
918 */
919 public static Matrix plus(Matrix A, Matrix B)
920 {
921 return A.plus(B);
922 }
923
924 /**Element-by-element power
925 @param A Matrix.
926 @param p double
927 @return A.^p
928 */
929
930 /*M
931 <syntax>
932 <matlab>X = power(A,p);</matlab>
933 <java>X = power(A,p);</java>
934 </syntax>
935 */
936 public static Matrix power(Matrix A, double p)
937 {
938 return A.ebePow(p);
939 }
940
941 /**Element-by-element power
942 @param A Matrix.
943 @param B another matrix
944 @return A.^B
945 */
946
947 /*M
948 <syntax>
949 <matlab>X = power(A,B);</matlab>
950 <java>X = power(A,B);</java>
951 </syntax>
952 */
953 public static Matrix power(Matrix A, Matrix B)
954 {
955 return A.ebePow(B);
956 }
957
958 /** Generate a row matrix, each column contents the product value of the columns.
959 @param A Matrix.
960 @return An 1-by-n matrix.
961 */
962
963 /*M
964 <syntax>
965 <matlab>X = prod(A);</matlab>
966 <java>X = prod(A);</java>
967 </syntax>
968 */
969 public static Matrix prod(Matrix A)
970 {
971 return A.prod();
972 }
973
974 /** QR Decomposition
975 @param A Matrix.
976 @return Q
977 */
978
979 /*M
980 <syntax>
981 <matlab>[Q,R] = qr(A);</matlab>
982 <java>Q = qr_Q(A);</java>
983 </syntax>
984 */
985 public static Matrix qr_Q(Matrix A)
986 {
987 return A.qr().getQ();
988 }
989
990 /** QR Decomposition
991 @param A Matrix.
992 @return R
993 */
994
995 /*M
996 <syntax>
997 <matlab>[Q,R] = qr(A);</matlab>
998 <java>R = qr_R(A);</java>
999 </syntax>
1000 */
1001 public static Matrix qr_R(Matrix A)
1002 {
1003 return A.qr().getR();
1004 }
1005
1006 /* ----------------------
1007 Public Methods
1008 * ---------------------- */
1009
1010 //////////////////////////////////////////
1011 //Static constructors for simple matrix.//
1012 //////////////////////////////////////////
1013
1014 /** Generate matrix with random elements
1015 @param m Number of rows.
1016 @param n Number of colums.
1017 @return An m-by-n matrix with uniformly distributed random elements.
1018 */
1019
1020 /*M
1021 <syntax>
1022 <matlab>X = rand(m,n);</matlab>
1023 <java>X = rand(m,n);</java>
1024 </syntax>
1025 */
1026 public static Matrix rand(int m, int n)
1027 {
1028 return Matrix.random(m, n);
1029 }
1030
1031 /** Matrix rank
1032 @param A Matrix.
1033 @return effective numerical rank, obtained from SVD.
1034 */
1035
1036 /*M
1037 <syntax>
1038 <matlab>d = rank(A);</matlab>
1039 <java>d = rank(A);</java>
1040 </syntax>
1041 */
1042 public static int rank(Matrix A)
1043 {
1044 return A.rank();
1045 }
1046
1047 /** Matrix reshape by Row.
1048 @param A Matrix.
1049 @param m2 number of rows
1050 @param n2 number of columns
1051 @return reshaped matrix
1052 */
1053
1054 /*M
1055 <syntax>
1056 <matlab>X = reshape(A,m,n);</matlab>
1057 <java>X = reshape(A,m,n);</java>
1058 </syntax>
1059 */
1060 public static Matrix reshape(Matrix A, int m2, int n2)
1061 {
1062 return A.reshape(m2, n2);
1063 }
1064
1065 ////////////////////////////////
1066 //Modify dimensions of matrix.//
1067 ////////////////////////////////
1068
1069 /** Matrix resize.
1070 @param A Matrix.
1071 @param m2 number of rows
1072 @param n2 number of columns
1073 @return resized matrix
1074 */
1075 public static Matrix resize(Matrix A, int m2, int n2)
1076 {
1077 return A.resize(m2, n2);
1078 }
1079
1080 /** Save the Matrix in an ASCII file.
1081 @param A Matrix.
1082 @param fileName filename to save in.
1083 */
1084
1085 /*M
1086 <syntax>
1087 <matlab>save('A.dat','A','-ASCII');</matlab>
1088 <java>save('A.dat',A);</java>
1089 </syntax>
1090 */
1091 public static void save(String fileName, Matrix A)
1092 {
1093 A.toFile(fileName);
1094 }
1095
1096 ////////////////////////////////////////////////////////////
1097 //Basic and advanced Set methods for matrix and submatrix.//
1098 ////////////////////////////////////////////////////////////
1099
1100 /** Set a single element.
1101 @param A Matrix.
1102 @param i Row index.
1103 @param j Column index.
1104 @param s A(i,j).
1105 */
1106
1107 /*M
1108 <syntax>
1109 <matlab>A(i,j) = s;</matlab>
1110 <java>set(A,i,j,s);</java>
1111 </syntax>
1112 */
1113 public static void set(Matrix A, int i, int j, double s)
1114 {
1115 A.set(i - 1, j - 1, s);
1116 }
1117
1118 /** Set a submatrix.
1119 @param A Matrix.
1120 @param i0 Initial row index
1121 @param i1 Final row index
1122 @param j0 Initial column index
1123 @param j1 Final column index
1124 @param X subMatrix to add
1125 */
1126
1127 /*M
1128 <syntax>
1129 <matlab>A(i0:i1,j0:i1) = X;</matlab>
1130 <java>set(A,i0,i1,j0,i1,X);</java>
1131 </syntax>
1132 */
1133 public static void set(Matrix A, int i0, int i1, int j0, int j1, Matrix X)
1134 {
1135 A.setMatrix(i0 - 1, i1 - 1, j0 - 1, j1 - 1, X);
1136 }
1137
1138 /**Element-by-element sinus
1139 @param A Matrix.
1140 @return sin.(A)
1141 */
1142
1143 /*M
1144 <syntax>
1145 <matlab>X = sin(A);</matlab>
1146 <java>X = sin(A);</java>
1147 </syntax>
1148 */
1149 public static Matrix sin(Matrix A)
1150 {
1151 return A.ebeSin();
1152 }
1153
1154 /** Get row dimension.
1155 @param A Matrix.
1156 @param dim Dimension to return (1 = number of rows, 2 = number of columns).
1157 @return the number of rows or columns.
1158 */
1159
1160 /*M
1161 <syntax>
1162 <matlab>i = size(A,dim);</matlab>
1163 <java>i = size(A,dim);</java>
1164 </syntax>
1165 */
1166 public static int size(Matrix A, int dim)
1167 {
1168 if (dim == 1)
1169 {
1170 return A.getRowDimension();
1171 }
1172 else if (dim == 2)
1173 {
1174 return A.getColumnDimension();
1175 }
1176 else
1177 {
1178 return 0;
1179 }
1180 }
1181
1182 /** Solve A*X = B
1183 @param A Matrix.
1184 @param B right hand side
1185 @return solution if A is square, least squares solution otherwise
1186 */
1187
1188 /*M
1189 <syntax>
1190 <matlab>X = A\B;</matlab>
1191 <java>X = solve(A,B);</java>
1192 </syntax>
1193 */
1194 public static Matrix solve(Matrix A, Matrix B)
1195 {
1196 return A.solve(B);
1197 }
1198
1199 /////////////////////////////////////////
1200 //Advanced functions like sort or find.//
1201 /////////////////////////////////////////
1202
1203 /** Generate a column-permuted matrix, rows are permuted in order to sort the column 'c'
1204 @param A Matrix.
1205 @return An int[] Array.
1206 */
1207
1208 /*M
1209 <syntax>
1210 <matlab>[Y,I] = sort(A);</matlab>
1211 <java>I = sort_I(A);</java>
1212 </syntax>
1213 */
1214 public static Matrix sort_I(Matrix A)
1215 {
1216 Matrix X = new Matrix(A.getRowDimension(), A.getColumnDimension());
1217
1218 for (int i = 0; i < A.getColumnDimension(); i++)
1219 {
1220 int[] Ii = A.sort(i);
1221
1222 for (int j = 0; j < Ii.length; j++)
1223 {
1224 X.set(i, j, Ii[j] + 1);
1225 }
1226 }
1227
1228 return X;
1229 }
1230
1231 /** Generate a column-permuted matrix, rows are permuted in order to sort the column 'c'
1232 @param A Matrix.
1233 @return An m-by-n matrix.
1234 */
1235
1236 /*M
1237 <syntax>
1238 <matlab>[Y,I] = sort(A);</matlab>
1239 <java>Y = sort_Y(A);</java>
1240 </syntax>
1241 */
1242 public static Matrix sort_Y(Matrix A)
1243 {
1244 Matrix X = new Matrix(A.getRowDimension(), A.getColumnDimension());
1245
1246 for (int i = 0; i < A.getColumnDimension(); i++)
1247 {
1248 Matrix C = A.sortedMatrix(i).getColumn(i);
1249 X.setColumn(i, C);
1250 }
1251
1252 return X;
1253 }
1254
1255 /**Element-by-element inverse
1256 @param A Matrix.
1257 @return sqrt.(A)
1258 */
1259
1260 /*M
1261 <syntax>
1262 <matlab>X = sqrt(A);</matlab>
1263 <java>X = sqrt(A);</java>
1264 </syntax>
1265 */
1266 public static Matrix sqrt(Matrix A)
1267 {
1268 return A.ebeSqrt();
1269 }
1270
1271 /** Generate a row matrix, each column contents the sum value of the columns.
1272 @param A Matrix.
1273 @return An 1-by-n matrix.
1274 */
1275
1276 /*M
1277 <syntax>
1278 <matlab>X = sum(A);</matlab>
1279 <java>X = sum(A);</java>
1280 </syntax>
1281 */
1282 public static Matrix sum(Matrix A)
1283 {
1284 return A.sum();
1285 }
1286
1287 /** Singular Value Decomposition
1288 @param A Matrix.
1289 @return S
1290 */
1291
1292 /*M
1293 <syntax>
1294 <matlab>[U,S,V] = svd(A);</matlab>
1295 <java>S = svd_S(A);</java>
1296 </syntax>
1297 */
1298 public static Matrix svd_S(Matrix A)
1299 {
1300 return A.svd().getS();
1301 }
1302
1303 /** Singular Value Decomposition
1304 @param A Matrix.
1305 @return U
1306 */
1307
1308 /*M
1309 <syntax>
1310 <matlab>[U,S,V] = svd(A);</matlab>
1311 <java>U = svd_U(A);</java>
1312 </syntax>
1313 */
1314 public static Matrix svd_U(Matrix A)
1315 {
1316 return A.svd().getU();
1317 }
1318
1319 /** Singular Value Decomposition
1320 @param A Matrix.
1321 @return V
1322 */
1323
1324 /*M
1325 <syntax>
1326 <matlab>[U,S,V] = svd(A);</matlab>
1327 <java>V = svd_V(A);</java>
1328 </syntax>
1329 */
1330 public static Matrix svd_V(Matrix A)
1331 {
1332 return A.svd().getV();
1333 }
1334
1335 /** Matrix transpose.
1336 @param A Matrix.
1337 @return A'
1338 */
1339
1340 /*M
1341 <syntax>
1342 <matlab>X = A';</matlab>
1343 <java>X = t(A);</java>
1344 </syntax>
1345 */
1346 public static Matrix t(Matrix A)
1347 {
1348 return A.transpose();
1349 }
1350
1351 /** Multiply a matrix by a scalar, C = s*A
1352 @param A Matrix.
1353 @param s scalar
1354 @return s*A
1355 */
1356
1357 /*M
1358 <syntax>
1359 <matlab>X = A*s;</matlab>
1360 <java>X = times(A,s);</java>
1361 </syntax>
1362 */
1363 public static Matrix times(Matrix A, double s)
1364 {
1365 return A.times(s);
1366 }
1367
1368 /** Linear algebraic matrix multiplication, A * B
1369 @param A Matrix.
1370 @param B another matrix
1371 @return Matrix product, A * B
1372 */
1373
1374 /*M
1375 <syntax>
1376 <matlab>X = A*B;</matlab>
1377 <java>X = times(A,B);</java>
1378 </syntax>
1379 */
1380 public static Matrix times(Matrix A, Matrix B)
1381 {
1382 return A.times(B);
1383 }
1384
1385 /** Matrix trace.
1386 @param A Matrix.
1387 @return sum of the diagonal elements.
1388 */
1389
1390 /*M
1391 <syntax>
1392 <matlab>d = trace(A);</matlab>
1393 <java>d = trace(A);</java>
1394 </syntax>
1395 */
1396 public static double trace(Matrix A)
1397 {
1398 return A.trace();
1399 }
1400
1401 /** Construct an m-by-n matrix of random numbers from an triangular random variable.
1402 @param m Number of rows.
1403 @param n Number of columns.
1404 @param min Min of the uniform random variable.
1405 @param mod Mode of the uniform random variable.
1406 @param max Max of the uniform random variable.
1407 @return A RandomMatrix.
1408 */
1409 public static RandomMatrix triangRnd(int m, int n, double min, double mod,
1410 double max)
1411 {
1412 return RandomMatrix.triangular(m, n, min, mod, max);
1413 }
1414
1415 ///////////////////////////////////
1416 //Algebraic Functions for Matrix.//
1417 ///////////////////////////////////
1418
1419 /** Unary minus
1420 @param A Matrix.
1421 @return -A
1422 */
1423
1424 /*M
1425 <syntax>
1426 <matlab>X = -A;</matlab>
1427 <java>X = uminus(A);</java>
1428 </syntax>
1429 */
1430 public static Matrix uminus(Matrix A)
1431 {
1432 return A.uminus();
1433 }
1434
1435 /** Construct an m-by-n matrix of random numbers from an uniform random variable.
1436 @param m Number of rows.
1437 @param n Number of columns.
1438 @param min Min of the uniform random variable.
1439 @param max Max of the uniform random variable.
1440 @return A RandomMatrix.
1441 */
1442
1443 /*M
1444 <syntax>
1445 <matlab>X = unifrnd(min,max,m,n);</matlab>
1446 <java>X = unifRnd(min,max,m,n);</java>
1447 </syntax>
1448 */
1449 public static RandomMatrix unifRnd(int m, int n, double min, double max)
1450 {
1451 return RandomMatrix.uniform(m, n, min, max);
1452 }
1453
1454 /** Generate a variance matrix.
1455 @param A Matrix.
1456 @return An 1-by-n matrix.
1457 */
1458
1459 /*M
1460 <syntax>
1461 <matlab>X = var(A);</matlab>
1462 <java>X = var(A);</java>
1463 </syntax>
1464 */
1465 public static Matrix var(Matrix A)
1466 {
1467 return new RandomMatrix(A).var();
1468 }
1469
1470 /* ------------------------
1471 Constructors
1472 * ------------------------ */
1473
1474 /** Construct an m-by-n matrix of zeros.
1475 @param m Number of rows.
1476 @param n Number of colums.
1477 @return An m-by-n matrix of zeros.
1478 */
1479
1480 /*M
1481 <syntax>
1482 <matlab>X = zeros(m,n);</matlab>
1483 <java>X = zeros(m,n);</java>
1484 </syntax>
1485 */
1486 public static Matrix zeros(int m, int n)
1487 {
1488 return new Matrix(m, n);
1489 }
1490}
1491///////////////////////////////////////////////////////////////////////////////
1492// END OF FILE.
1493///////////////////////////////////////////////////////////////////////////////