oct_get_prpi.cpp

Go to the documentation of this file.
00001 #include <oct.h>
00002 
00003 double *oct_GetPr(octave_value arg){
00004     double *pr;
00005     int i, j;
00006 
00007     if (arg.is_real_type()) {
00008         pr = (double *) malloc(arg.rows() * arg.columns() * sizeof(double));
00009         for ( j = 0; j < arg.columns(); j++)
00010             for (i = 0; i < arg.rows(); i++)
00011                 *(pr + i + (j * arg.rows())) = (arg.matrix_value())(i, j);
00012     } else {
00013         pr = (double *) malloc(arg.rows() * arg.columns() * sizeof(double));
00014         for (j = 0; j<arg.columns(); j++)
00015             for (i = 0; i < arg.rows(); i++)
00016                 *(pr + i + (j * arg.rows())) =
00017                 real((arg.complex_matrix_value())(i, j));
00018     }
00019 
00020     return pr;
00021 }
00022 
00023 double *oct_GetPi(octave_value arg) {
00024     double *pi;
00025     int i, j;
00026  
00027     if (arg.is_real_type()) {
00028         pi = (double *) malloc(arg.rows() * arg.columns() * sizeof(double));
00029         for (j = 0; j < arg.columns(); j++)
00030             for (i = 0; i < arg.rows(); i++)
00031                 *(pi + i + (j * arg.rows())) = 0;
00032     } else {
00033         pi = (double *) malloc(arg.rows() * arg.columns() * sizeof(double));
00034         for (j = 0; j < arg.columns(); j++)
00035             for (i = 0; i < arg.rows(); i++)
00036                 *(pi + i + (j * arg.rows())) =
00037                 imag((arg.complex_matrix_value())(i, j));
00038     }
00039  
00040     return pi;
00041 }
00042 
00043 double *oct_GetSparsePr(octave_value arg) {
00044     double *pr;
00045     int i, j;
00046     int count;
00047     int index;
00048 
00049     if (arg.is_real_type()) {
00050         count = 0;
00051         for (j = 0; j < arg.columns(); j++)
00052             for (i = 0; i < arg.rows(); i++)
00053                 if ((arg.matrix_value())(i, j) != 0) count++;
00054     
00055         pr = (double *) malloc(count * sizeof(double));
00056         index = 0;
00057         for (j = 0; j < arg.columns(); j++)
00058             for(i = 0; i < arg.rows(); i++)
00059                 if( (arg.matrix_value())(i,j) != 0 ) {
00060                     *(pr + index) = (arg.matrix_value())(i, j);
00061                     index++;
00062                 }
00063     } else {
00064         count = 0;
00065         for (j = 0; j < arg.columns(); j++)
00066             for (i = 0; i < arg.rows(); i++)
00067                 if ((real((arg.complex_matrix_value())(i, j)) != 0) ||
00068                     (imag((arg.complex_matrix_value())(i, j)) != 0) )
00069                     count++;
00070     
00071         pr = (double *) malloc(count * sizeof(double));
00072         index = 0;
00073         for (j = 0; j < arg.columns(); j++)
00074             for (i = 0; i < arg.rows(); i++)
00075                 if ((real((arg.complex_matrix_value())(i, j)) != 0) ||
00076                     (imag((arg.complex_matrix_value())(i, j)) != 0)) {
00077                     *(pr + index) = real((arg.complex_matrix_value())(i, j));
00078                     index++;
00079                 }
00080 
00081     }
00082 
00083     return pr;
00084 }
00085 
00086 double *oct_GetSparsePi(octave_value arg) {
00087     double *pi;
00088     int    i, j;
00089     int    count;
00090     int    index;
00091   
00092     if (arg.is_real_type()) {
00093         count = 0;
00094         for (j = 0; j < arg.columns(); j++)
00095             for (i = 0; i < arg.rows(); i++)
00096                 if ((arg.matrix_value())(i, j) != 0) count++;
00097                
00098         pi = (double *) malloc(count * sizeof(double));
00099         index = 0;
00100         for (j = 0; j < arg.columns(); j++)
00101             for (i = 0; i<arg.rows(); i++)
00102                 if ((arg.matrix_value())(i, j) != 0) {
00103                     *(pi + index) = 0;
00104                     index++;
00105                 }
00106     } else {
00107         count = 0;
00108         for (j = 0; j < arg.columns(); j++)
00109             for (i = 0; i < arg.rows(); i++)
00110                 if ((real((arg.complex_matrix_value())(i, j)) != 0) ||
00111                     (imag((arg.complex_matrix_value())(i, j)) != 0))
00112                     count++;
00113   
00114         pi = (double *) malloc(count*sizeof(double));
00115         index = 0;
00116         for (j = 0; j < arg.columns(); j++)
00117             for (i = 0; i < arg.rows(); i++)
00118                 if ((real((arg.complex_matrix_value())(i, j)) != 0) ||
00119                     (imag((arg.complex_matrix_value())(i, j)) != 0)) {
00120                     *(pi + index) = imag((arg.complex_matrix_value())(i, j));
00121                     index++;
00122                 }
00123       
00124     }
00125 
00126     return pi;
00127 }
00128 
00129 int *oct_GetSparseIr(octave_value arg) {
00130     int    *Ir;
00131     int    i, j;
00132     int    count;
00133     int    index;
00134 
00135     if (arg.is_real_type()) {
00136         count = 0;
00137         for (j = 0; j < arg.columns(); j++)
00138             for (i = 0; i < arg.rows(); i++)
00139                 if ((arg.matrix_value())(i, j) != 0) count++;
00140     
00141         Ir = (int *) malloc(count * sizeof(int));
00142         index = 0;
00143         for (j = 0; j < arg.columns(); j++)
00144             for (i = 0; i < arg.rows(); i++)
00145                 if ((arg.matrix_value())(i, j) != 0) {
00146                     *(Ir + index) = i;
00147                     index++;
00148                 }
00149     } else {
00150         count = 0;
00151         for (j = 0; j < arg.columns(); j++)
00152             for (i = 0; i < arg.rows(); i++)
00153                 if ((real((arg.complex_matrix_value())(i, j)) != 0) ||
00154                     (imag((arg.complex_matrix_value())(i, j)) != 0) )
00155                     count++;
00156         
00157         Ir = (int *) malloc(count * sizeof(int));
00158         index = 0;
00159         for (j = 0; j < arg.columns(); j++)
00160             for (i = 0; i < arg.rows(); i++)
00161                 if ((real((arg.complex_matrix_value())(i, j)) != 0) ||
00162                     (imag((arg.complex_matrix_value())(i, j)) != 0)) {
00163                     *(Ir + index) = i;
00164                     index++;
00165                 }
00166               
00167     }
00168 
00169     return Ir;
00170 }
00171 
00172 int *oct_GetSparseJc(octave_value arg) {
00173     int    *Jc;
00174     int    i, j;
00175     int    count;
00176 
00177     Jc = (int *) malloc(arg.columns() * sizeof(int) + 1);
00178 
00179     if (arg.is_real_type()) {
00180         count = 0;
00181         for (j = 0; j < arg.columns(); j++)
00182           for (i = 0; i < arg.rows(); i++)
00183              if ((arg.matrix_value())(i, j) != 0 ) count++;
00184         *(Jc + arg.columns()) = count;
00185 
00186         count = 0;
00187         for (j = 0; j < arg.columns(); j++) {
00188             *(Jc + j) = count;
00189             for (i = 0; i < arg.rows(); i++)
00190                 if ((arg.matrix_value())(i, j) != 0) count++;
00191         }
00192     } else {
00193         count = 0;
00194         for (j = 0;j<arg.columns();j++)
00195             for (i = 0; i < arg.rows(); i++)
00196                 if ((real((arg.complex_matrix_value())(i,j)) != 0) || 
00197                     (imag((arg.complex_matrix_value())(i,j)) != 0) )
00198                     count++;
00199         *(Jc + arg.columns()) = count;
00200 
00201         count = 0;
00202         for (j = 0; j < arg.columns(); j++)
00203         {
00204           *(Jc + j) = count;
00205           for (i = 0; i< arg.rows(); i++)
00206              if ((real((arg.complex_matrix_value())(i, j)) != 0) ||
00207                 (imag((arg.complex_matrix_value())(i, j)) != 0)) count++;
00208         }
00209     }
00210 
00211     return Jc;
00212 }