bool matrix_equals(Matrix M1, Matrix M2) { assert(is_matrix(M1) && is_matrix(M2)); if(!(M1->r == M2->r && M1->c == M2->c)) return false; for(int i = 0; i < M1->r; i++) for(int j = 0; j < M1->c; j++) if(M1->A[i][j] != M2->A[i][j]) return false; return true; }
Matrix matrix_transpose(Matrix M) { assert(is_matrix(M)); int r = M->r; int c = M->c; Matrix N = matrix_new_empty(c, r); for(int i = 0; i < r; i++) for(int j = 0; j < c; j++) N->A[j][i] = M->A[i][j]; assert(is_matrix(N)); return N; }
Matrix matrix_multiply_scalar(Matrix M, double n) { assert(is_matrix(M)); int r = M->r; int c = M->c; Matrix N = matrix_new_empty(r, c); for(int i = 0; i < r; i++) for(int j = 0; j < c; j++) { assert(FLT_MAX / n >= M->A[i][j]); N->A[i][j] = n * M->A[i][j]; } assert(is_matrix(N)); return N; }
Matrix matrix_multiply(Matrix M1, Matrix M2) { assert(is_matrix(M1) && is_matrix(M2)); assert(M1->c == M2->r); int r = M1->r; int c = M2->c; int m = M1->c; Matrix M = matrix_new_empty(r, c); for(int i = 0; i < r; i++) for(int j = 0; j < c; j++) for(int k = 0; k < m; k++) M->A[i][j] += M1->A[i][k] * M2->A[k][j]; assert(is_matrix(M)); return M; }
Matrix matrix_subtract(Matrix M1, Matrix M2) { assert(is_matrix(M1) && is_matrix(M2)); assert(M1->r == M2->r && M1->c == M2->c); int r = M1->r; int c = M1->c; Matrix M = matrix_new_empty(r, c); for(int i = 0; i < r; i++) for(int j = 0; j < c; j++) { assert(FLT_MIN + M1->A[i][j] >= M2->A[i][j]); M->A[i][j] = M1->A[i][j] - M2->A[i][j]; } assert(is_matrix(M)); return M; }
Matrix* matrix_qr_decomposition(Matrix M) { assert(is_matrix(M)); int m = M->r; int n = M->c; Matrix Q = matrix_new_empty(m, n); for(int i = 0; i < n; i++) { double* u = matrix_column_vector(M, i); double* a = matrix_column_vector(M, i); for(int k = 0; k < i; k++) { double* e = matrix_column_vector(Q, k); double* p = vector_projection(e, a, m); free(e); for(int j = 0; j < m; j++) u[j] -= p[j]; free(p); } free(a); double* e = vector_normalize(u, m); free(u); for(int l = 0; l < m; l++) Q->A[l][i] = e[l]; free(e); } Matrix Qt = matrix_transpose(Q); Matrix R = matrix_multiply(Qt, M); matrix_free(Qt); Matrix* QR = calloc(2, sizeof(Matrix)); QR[0] = Q; QR[1] = R; return QR; }
/* ---------------------------------------------------------------------------- function: cmap_getfontmatrix author: Eric Penfold creation date: 13-Aug-1997 last modification: ##-###-#### arguments: cmapdict (Input) fontid (Input) matrix (Output) description: Obtains the font matrix from the CMap to use with the specified descendant font. If no matrices are defined at all, or no matrix is defined for this fontid, then 'matrix' will be set to a null object. Returns FALSE if the object in the matrix array is not a valid matrix, or if the fontid is invalid (i.e. the matrix array has fewer entries); TRUE is otherwise returned. ---------------------------------------------------------------------------- */ Bool cmap_getfontmatrix(OBJECT *cmapdict, int32 fontid, OBJECT *matrix) { OBJECT *cmap, *matblk; OMATRIX omat; /* Extract CMap */ if ( oType(*cmapdict) != ODICTIONARY ) return FAILURE(FALSE); /* Error - Invalid dictionary */ cmap = fast_extract_hash_name(cmapdict, NAME_CodeMap); /* Extract matrix block */ if ( oType(*cmap) != ODICTIONARY ) return FAILURE(FALSE); /* Error - Invalid dictionary */ matblk = fast_extract_hash_name(cmap, NAME_usematrixblock); if ( !matblk ) { object_store_null(matrix); /* No usematrix defined, use defaults */ } else if ( oType(*matblk) != OARRAY || theLen(*matblk) <= fontid || !is_matrix(oArray(*matblk) + fontid, &omat) ) { return FAILURE(FALSE); /* usematrix definition is not valid (for this fontid) */ } else Copy(matrix, oArray(*matblk) + fontid); return TRUE; }
Matrix matrix_cofactor(Matrix M, int i, int j) { assert(is_matrix(M)); assert(0 <= i && i < M->r); assert(0 <= j && j < M->c); Matrix C = matrix_new_empty(M->r - 1, M->c - 1); int r = 0; for(int k = 0; k < M->r; k++) { int c = 0; if(k != i) { for(int l = 0; l < M->c; l++) { if(l != j) { C->A[r][c] = M->A[k][l]; c++; } } r++; } } assert(is_matrix(C)); return C; }
static void to_matrix(void) { HklQuaternion q_ref = {{1./sqrt(2), 0, 0, 1./sqrt(2)}}; HklMatrix *m_ref = hkl_matrix_new_full(0,-1, 0, 1, 0, 0, 0, 0, 1); HklMatrix *m = hkl_matrix_new(); hkl_quaternion_to_matrix(&q_ref, m); is_matrix(m_ref, m, __func__); hkl_matrix_free(m_ref); hkl_matrix_free(m); }
bool is_standard( const builtin_types& btc ){ if (btc == builtin_types::_sint32 || btc == builtin_types::_uint32 || btc == builtin_types::_sint64 || btc == builtin_types::_uint64 || btc == builtin_types::_float || btc == builtin_types::_double) { return true; } if ( is_vector(btc) || is_matrix(btc) ){ return is_standard(scalar_of(btc)); } return false; }
builtin_types replace_scalar( builtin_types const& btc, builtin_types const& scalar_btc ) { assert( is_scalar(scalar_btc) ); if( !is_scalar(scalar_btc) ) { return scalar_btc; } if( is_vector(btc) ) { return vector_of( scalar_btc, vector_size(btc) ); } else if ( is_matrix(btc) ) { return matrix_of( scalar_btc, vector_size(btc), vector_count(btc) ); } else { return scalar_btc; } }
void make_split(Tree* MTree, Tnode * Root) {//get all the children of a certain node if(is_matrix(Root)) { Root->ChildTnodeArray = 0; Root->ChildTnodeNum = 0; return; } Tnode * CreatedTnode1, * CreatedTnode2; CreatedTnode1 = (Tnode *)malloc(sizeof(Tnode)); CreatedTnode2 = (Tnode *)malloc(sizeof(Tnode)); step_split_differentlevel(MTree, Root, CreatedTnode1, CreatedTnode2); if(((float)CreatedTnode1->TTransactionNum) / Root->TTransactionNum < FThreshold || ((float)CreatedTnode1->TTransactionNum) / MTree->Root->TTransactionNum < WThreshold) {//if a spliting is failed, it is based on the rate of the number of children in created1(if the bigger node is too small) MTree->TnodeNum -= 2; Root->ChildTnodeNum = 0; Root->ChildTnodeArray = 0; return; } //below we should deal with the case where the bigger node is so big that we should discard the rest node else if( ((float)CreatedTnode2->TTransactionNum) / Root->TTransactionNum < FThreshold || ((float)CreatedTnode2->TTransactionNum) / MTree->Root->TTransactionNum < WThreshold) {//if the bigger node is too big MTree->TnodeNum --; UsedTransactionNum -= CreatedTnode2->TTransactionNum; en_queue(Root->ChildTnodeArray[0]); return; } Tnode * CreatedTnode3; CreatedTnode3 = step_split_samelevel(MTree,CreatedTnode2); for(;;) { if(((float)CreatedTnode2->TTransactionNum) / CreatedTnode2->FatherTnode->TTransactionNum < FThreshold || ((float)CreatedTnode2->TTransactionNum) / MTree->Root->TTransactionNum < WThreshold) {// if the bigger node is too small, we do retreat for this node // usually we should stop spliting at this node, and this means some Transactions are discarded. We deal with that case from two aspects if((CreatedTnode2->TTransactionNum + (float)CreatedTnode3->TTransactionNum) / CreatedTnode2->FatherTnode->TTransactionNum > DiscardThreshold)//if the number of effective children discarded is more than certain percentage of the number in Fathernode {//we refuse to discard too many children, we would rather stop growing. And this is to handle the case where there are too many 1-transaction-nodes which is too specific MTree->TnodeNum -= 1; MTree->TnodeNum -= Root->ChildTnodeNum; Root->ChildTnodeArray = NULL; Root->ChildTnodeNum = 0; return; } MTree->TnodeNum -= 2; Root->ChildTnodeNum --; CreatedTnode2->PreviousTnode->NextTnode = NULL;// retreat, prune at the previous node UsedTransactionNum -= (CreatedTnode3->TTransactionNum + CreatedTnode2->TTransactionNum); break; } else if(((float)CreatedTnode3->TTransactionNum) / CreatedTnode2->FatherTnode->TTransactionNum < FThreshold || ((float)CreatedTnode3->TTransactionNum) / MTree->Root->TTransactionNum < WThreshold) { MTree->TnodeNum -= 1; CreatedTnode2->NextTnode = NULL; UsedTransactionNum -= CreatedTnode3->TTransactionNum; break; } CreatedTnode2 = CreatedTnode3; CreatedTnode3 = step_split_samelevel(MTree,CreatedTnode2); } Tnode ** ChildTnodeArray; ChildTnodeArray = (Tnode **)malloc(Root->ChildTnodeNum *sizeof(Tnode *)); Tnode * FirstChild; FirstChild = *(Root->ChildTnodeArray); for( int i = 0; i < Root->ChildTnodeNum; i ++) { ChildTnodeArray[i] = FirstChild; FirstChild = FirstChild->NextTnode; } Root->ChildTnodeArray = ChildTnodeArray; for( int i = 0; i < Root->ChildTnodeNum; i ++) en_queue(Root->ChildTnodeArray[i]); }
/** * The Stan print function. * * @param argc Number of arguments * @param argv Arguments * * @return 0 for success, * non-zero otherwise */ int main(int argc, const char* argv[]) { if (argc == 1) { print_usage(); return 0; } // Parse any arguments specifying filenames std::ifstream ifstream; std::vector<std::string> filenames; for (int i = 1; i < argc; i++) { if (std::string(argv[i]).find("--autocorr=") != std::string::npos) continue; if (std::string(argv[i]).find("--sig_figs=") != std::string::npos) continue; if (std::string("--help") == std::string(argv[i])) { print_usage(); return 0; } ifstream.open(argv[i]); if (ifstream.good()) { filenames.push_back(argv[i]); ifstream.close(); } else { std::cout << "File " << argv[i] << " not found" << std::endl; } } if (!filenames.size()) { std::cout << "No valid input files, exiting." << std::endl; return 0; } // Parse specified files Eigen::VectorXd warmup_times(filenames.size()); Eigen::VectorXd sampling_times(filenames.size()); Eigen::VectorXi thin(filenames.size()); ifstream.open(filenames[0].c_str()); stan::io::stan_csv stan_csv = stan::io::stan_csv_reader::parse(ifstream); warmup_times(0) = stan_csv.timing.warmup; sampling_times(0) = stan_csv.timing.sampling; stan::mcmc::chains<> chains(stan_csv); ifstream.close(); thin(0) = stan_csv.metadata.thin; for (std::vector<std::string>::size_type chain = 1; chain < filenames.size(); chain++) { ifstream.open(filenames[chain].c_str()); stan_csv = stan::io::stan_csv_reader::parse(ifstream); chains.add(stan_csv); ifstream.close(); thin(chain) = stan_csv.metadata.thin; warmup_times(chain) = stan_csv.timing.warmup; sampling_times(chain) = stan_csv.timing.sampling; } double total_warmup_time = warmup_times.sum(); double total_sampling_time = sampling_times.sum(); // Compute largest variable name length const int skip = 0; std::string model_name = stan_csv.metadata.model; size_t max_name_length = 0; for (int i = skip; i < chains.num_params(); i++) if (chains.param_name(i).length() > max_name_length) max_name_length = chains.param_name(i).length(); for (int i = 0; i < 2; i++) if (chains.param_name(i).length() > max_name_length) max_name_length = chains.param_name(i).length(); // Prepare values int n = 9; Eigen::MatrixXd values(chains.num_params(), n); values.setZero(); Eigen::VectorXd probs(3); probs << 0.05, 0.5, 0.95; for (int i = 0; i < chains.num_params(); i++) { double sd = chains.sd(i); double n_eff = chains.effective_sample_size(i); values(i,0) = chains.mean(i); values(i,1) = sd / sqrt(n_eff); values(i,2) = sd; Eigen::VectorXd quantiles = chains.quantiles(i,probs); for (int j = 0; j < 3; j++) values(i,3+j) = quantiles(j); values(i,6) = n_eff; values(i,7) = n_eff / total_sampling_time; values(i,8) = chains.split_potential_scale_reduction(i); } // Prepare header Eigen::Matrix<std::string, Eigen::Dynamic, 1> headers(n); headers << "Mean", "MCSE", "StdDev", "5%", "50%", "95%", "N_Eff", "N_Eff/s", "R_hat"; // Set sig figs Eigen::VectorXi column_sig_figs(n); int sig_figs = 2; for (int k = 1; k < argc; k++) if (std::string(argv[k]).find("--sig_figs=") != std::string::npos) sig_figs = atoi(std::string(argv[k]).substr(11).c_str()); // Compute column widths Eigen::VectorXi column_widths(n); Eigen::Matrix<std::ios_base::fmtflags, Eigen::Dynamic, 1> formats(n); column_widths = calculate_column_widths(values, headers, sig_figs, formats); // Initial output std::cout << "Inference for Stan model: " << model_name << std::endl << chains.num_chains() << " chains: each with iter=(" << chains.num_kept_samples(0); for (int chain = 1; chain < chains.num_chains(); chain++) std::cout << "," << chains.num_kept_samples(chain); std::cout << ")"; // Timing output std::cout << "; warmup=(" << chains.warmup(0); for (int chain = 1; chain < chains.num_chains(); chain++) std::cout << "," << chains.warmup(chain); std::cout << ")"; std::cout << "; thin=(" << thin(0); for (int chain = 1; chain < chains.num_chains(); chain++) std::cout << "," << thin(chain); std::cout << ")"; std::cout << "; " << chains.num_samples() << " iterations saved." << std::endl << std::endl; std::string warmup_unit = "seconds"; if (total_warmup_time / 3600 > 1) { total_warmup_time /= 3600; warmup_unit = "hours"; } else if (total_warmup_time / 60 > 1) { total_warmup_time /= 60; warmup_unit = "minutes"; } std::cout << "Warmup took (" << std::fixed << std::setprecision(compute_precision(warmup_times(0), sig_figs, false)) << warmup_times(0); for (int chain = 1; chain < chains.num_chains(); chain++) std::cout << ", " << std::fixed << std::setprecision(compute_precision(warmup_times(chain), sig_figs, false)) << warmup_times(chain); std::cout << ") seconds, "; std::cout << std::fixed << std::setprecision(compute_precision(total_warmup_time, sig_figs, false)) << total_warmup_time << " " << warmup_unit << " total" << std::endl; std::string sampling_unit = "seconds"; if (total_sampling_time / 3600 > 1) { total_sampling_time /= 3600; sampling_unit = "hours"; } else if (total_sampling_time / 60 > 1) { total_sampling_time /= 60; sampling_unit = "minutes"; } std::cout << "Sampling took (" << std::fixed << std::setprecision(compute_precision(sampling_times(0), sig_figs, false)) << sampling_times(0); for (int chain = 1; chain < chains.num_chains(); chain++) std::cout << ", " << std::fixed << std::setprecision(compute_precision(sampling_times(chain), sig_figs, false)) << sampling_times(chain); std::cout << ") seconds, "; std::cout << std::fixed << std::setprecision(compute_precision(total_sampling_time, sig_figs, false)) << total_sampling_time << " " << sampling_unit << " total" << std::endl; std::cout << std::endl; // Header output std::cout << std::setw(max_name_length + 1) << ""; for (int i = 0; i < n; i++) { std::cout << std::setw(column_widths(i)) << headers(i); } std::cout << std::endl; // Value output for (int i = skip; i < chains.num_params(); i++) { if (!is_matrix(chains.param_name(i))) { std::cout << std::setw(max_name_length + 1) << std::left << chains.param_name(i); std::cout << std::right; for (int j = 0; j < n; j++) { std::cout.setf(formats(j), std::ios::floatfield); std::cout << std::setprecision( compute_precision(values(i,j), sig_figs, formats(j) == std::ios_base::scientific)) << std::setw(column_widths(j)) << values(i, j); } std::cout << std::endl; } else { std::vector<int> dims = dimensions(chains, i); std::vector<int> index(dims.size(), 1); int max = 1; for (int j = 0; j < dims.size(); j++) max *= dims[j]; for (int k = 0; k < max; k++) { int param_index = i + matrix_index(index, dims); std::cout << std::setw(max_name_length + 1) << std::left << chains.param_name(param_index); std::cout << std::right; for (int j = 0; j < n; j++) { std::cout.setf(formats(j), std::ios::floatfield); std::cout << std::setprecision(compute_precision(values(param_index,j), sig_figs, formats(j) == std::ios_base::scientific)) << std::setw(column_widths(j)) << values(param_index, j); } std::cout << std::endl; next_index(index, dims); } i += max-1; } } /// Footer output std::cout << std::endl; std::cout << "Samples were drawn using " << stan_csv.metadata.algorithm << " with " << stan_csv.metadata.engine << "." << std::endl << "For each parameter, N_Eff is a crude measure of effective sample size," << std::endl << "and R_hat is the potential scale reduction factor on split chains (at " << std::endl << "convergence, R_hat=1)." << std::endl << std::endl; // Print autocorrelation, if desired for (int k = 1; k < argc; k++) { if (std::string(argv[k]).find("--autocorr=") != std::string::npos) { const int c = atoi(std::string(argv[k]).substr(11).c_str()); if (c < 0 || c >= chains.num_chains()) { std::cout << "Bad chain index " << c << ", aborting autocorrelation display." << std::endl; break; } Eigen::MatrixXd autocorr(chains.num_params(), chains.num_samples(c)); for (int i = 0; i < chains.num_params(); i++) { autocorr.row(i) = chains.autocorrelation(c, i); } // Format and print header std::cout << "Displaying the autocorrelations for chain " << c << ":" << std::endl; std::cout << std::endl; const int n_autocorr = autocorr.row(0).size(); int lag_width = 1; int number = n_autocorr; while ( number != 0) { number /= 10; lag_width++; } std::cout << std::setw(lag_width > 4 ? lag_width : 4) << "Lag"; for (int i = 0; i < chains.num_params(); ++i) { std::cout << std::setw(max_name_length + 1) << std::right << chains.param_name(i); } std::cout << std::endl; // Print body for (int n = 0; n < n_autocorr; ++n) { std::cout << std::setw(lag_width) << std::right << n; for (int i = 0; i < chains.num_params(); ++i) { std::cout << std::setw(max_name_length + 1) << std::right << autocorr(i, n); } std::cout << std::endl; } } } return 0; }
int main(void) { clock_t begin, end; double time_spent; begin = clock(); matrix* a = create_matrix(4, 4); value temp_a[16] = { 18, 60, 57, 96, 41, 24, 99, 58, 14, 30, 97, 66, 51, 13, 19, 85 }; insert_array(temp_a, a); matrix* b = create_matrix(4, 4); assert(insert_array(temp_a, b)); //tests check_boundaries assert(check_boundaries(1,1,a)); assert(check_boundaries(4,4,a)); assert(!check_boundaries(4,5,a)); assert(!check_boundaries(5,4,a)); assert(!check_boundaries(0,1,a)); assert(!check_boundaries(1,0,a)); assert(!check_boundaries(-1,1,a)); assert(!check_boundaries(1,-1,a)); //tests compare_matrices,insert_value and get_value assert(compare_matrices(a,b)); assert(insert_value(10,1,1,b)); assert(!compare_matrices(a,b)); assert(get_value(1,1,b)==10); assert(insert_value(18,1,1,b)); assert(compare_matrices(a,b)); //tests is_matrix matrix* c=a; assert(compare_matrices(a,c)); assert(!is_matrix(a,b)); assert(is_matrix(a,c)); //tests insert_value by trying to go outside the matrix assert(insert_value(1,1,1,c)); assert(insert_value(2,2,2,c)); assert(insert_value(3,3,3,c)); assert(insert_value(4,4,4,c)); assert(!insert_value(5,5,5,c)); assert(!insert_value(-1,-1,-1,c)); assert(!insert_value(-1,-1,1,c)); assert(!insert_value(-1,1,-1,c)); //test get_value assert(get_value(1,1,c)==1); assert(get_value(2,2,c)==2); assert(get_value(3,3,c)==3); assert(get_value(4,4,c)==4); assert(get_value(0,0,c)==0); assert(get_value(1,-1,c)==0); assert(get_value(-1,1,c)==0); assert(get_value(5,5,c)==0); //tests insert and get without boundary checks insert_value_without_check(4,1,1,c); insert_value_without_check(3,2,2,c); insert_value_without_check(2,3,3,c); insert_value_without_check(1,4,4,c); assert(get_value_without_check(1,1,c)==4); assert(get_value_without_check(2,2,c)==3); assert(get_value_without_check(3,3,c)==2); assert(get_value_without_check(4,4,c)==1); //tests add_matrices value temp_b[16]={ 36,120,114,192, 82,48,198,116, 28, 60, 194,132, 102,26,38,170}; assert(insert_array(temp_b,a)); matrix* d = create_matrix(4, 4); assert(add_matrices(b,b,d)); assert(compare_matrices(d,a)); //tests subtract_matrices value temp_c[16]={ 0,0,0,0, 0,0,0,0, 0, 0, 0,0, 0,0,0,0}; assert(insert_array(temp_c,a)); assert(subtract_matrices(b,b,d)); assert(compare_matrices(d,a)); //tests sum_of_row assert(insert_array(temp_a,a)); assert(sum_of_row(1,a)==231); assert(sum_of_row(4,a)==168); assert(sum_of_row(0,a)==0); assert(sum_of_row(5,a)==0); //tests sum_of_column assert(sum_of_column(1,a)==124); assert(sum_of_column(4,a)==305); assert(sum_of_column(0,a)==0); assert(sum_of_column(5,a)==0); //tests get_row_vector matrix* e = create_matrix(1, 4); value temp_d[4] = { 18, 60, 57, 96}; assert(insert_array(temp_d,e)); matrix* f = create_matrix(1, 4); assert(!get_row_vector(0,a,f)); assert(!get_row_vector(5,a,f)); assert(get_row_vector(1,a,f)); assert(compare_matrices(e,f)); //tests get_column_vector matrix* g = create_matrix(4, 1); assert(insert_array(temp_d,e)); matrix* h = create_matrix(1, 4); assert(!get_row_vector(0,a,h)); assert(!get_row_vector(5,a,h)); assert(get_row_vector(1,a,h)); assert(compare_matrices(e,h)); //tests mulitply_matrices assert(multiply_matrices(a,a,b)); value temp_f[16]={8478,5478,14319,17130, 6066,6760,15418,16792, 6206,5328,14431,15096, 6052,5047,7652,14129.00}; assert(insert_array(temp_f,d)); assert(compare_matrices(b,d)); assert(!multiply_matrices(a,h,b)); assert(!multiply_matrices(a,a,h)); //tests transpose_matrix value temp_g[16]={18,41,14,51, 60,24,30,13, 57,99,97,19, 96,58,66,85}; assert(insert_array(temp_g,d)); assert(transpose_matrix(a,b)); assert(compare_matrices(b,d)); assert(!transpose_matrix(e,b)); assert(!transpose_matrix(a,e)); //tests multiply_matrix_with_scalar value temp_h[16] = { 36, 120, 114, 192, 82, 48, 198, 116, 28, 60, 194, 132, 102, 26, 38, 170 }; assert(insert_array(temp_h,b)); multiply_matrix_with_scalar(2,a); assert(compare_matrices(a,b)); //test get_sub_matrix matrix* i=create_matrix(2,2); assert(insert_array(temp_a,a)); assert(get_sub_matrix(1,2,1,2,a,i)); matrix* j=create_matrix(2,2); value temp_i[4] = { 18, 60, 41, 24}; assert(insert_array(temp_i,j)); assert(compare_matrices(j,i)); value temp_j[4] = { 97, 66, 19, 85}; assert(insert_array(temp_j,j)); assert(get_sub_matrix(3,4,3,4,a,i)); assert(compare_matrices(j,i)); assert(!get_sub_matrix(2,4,3,4,a,i)); assert(!get_sub_matrix(3,4,2,4,a,i)); assert(!get_sub_matrix(4,5,4,5,a,i)); assert(!get_sub_matrix(0,1,0,1,a,i)); //test insert_row_vector assert(insert_array(temp_a,a)); value temp_k[16] = { 18, 60, 57, 96, 18, 60, 57, 96, 14, 30, 97, 66, 51, 13, 19, 85 }; assert(insert_array(temp_k,b)); assert(insert_array(temp_d,e)); assert(insert_row_vector(2,e,a)); assert(compare_matrices(a,b)); end = clock(); time_spent = (double)(end - begin) / CLOCKS_PER_SEC; printf("time taken was: %f \n",time_spent); free_matrix(a); free_matrix(b); free_matrix(d); free_matrix(e); free_matrix(f); free_matrix(g); free_matrix(h); free_matrix(i); free_matrix(j); return 0; }
static Bool set_cid_subfont(FONTinfo *fontInfo, OBJECT *dict) { CID0_CACHE *cid_font ; OBJECT *theo; OMATRIX matrix ; enum { mch_subdict_Private, mch_subdict_FontMatrix, mch_subdict_dummy }; static NAMETYPEMATCH mch_subdict[mch_subdict_dummy + 1] = { /* Use the enum above to index these */ { NAME_Private, 1, { ODICTIONARY }}, { NAME_FontMatrix, 2, { OARRAY, OPACKEDARRAY }}, DUMMY_END_MATCH }; enum { mch_private_Subrs, mch_private_SubrMapOffset, mch_private_SubrCount, mch_private_SDBytes, mch_private_RunInt, mch_private_dummy }; static NAMETYPEMATCH mch_private[mch_private_dummy + 1] = { /* Use the enum above to index these */ { NAME_Subrs | OOPTIONAL, 2, { OARRAY, OPACKEDARRAY }}, { NAME_SubrMapOffset | OOPTIONAL, 1, { OINTEGER }}, { NAME_SubrCount | OOPTIONAL, 1, { OINTEGER }}, { NAME_SDBytes | OOPTIONAL, 1, { OINTEGER }}, { NAME_RunInt | OOPTIONAL, 1, { ONAME }}, DUMMY_END_MATCH }; HQASSERT(fontInfo, "No font info") ; HQASSERT(dict, "No CID sub-dict") ; if ( (cid_font = cid0_set_font(fontInfo)) == NULL ) return FALSE ; VERIFY_OBJECT(cid_font, CID0_CACHE_NAME) ; /* Extract the necessary font parameters */ if ( !dictmatch(dict, mch_subdict) || !dictmatch(mch_subdict[mch_subdict_Private].result, mch_private) ) return error_handler(INVALIDFONT); if ( mch_private[mch_private_Subrs].result ) { cid_font->subrs = mch_private[mch_private_Subrs].result ; cid_font->subrcount = theLen(*cid_font->subrs) ; cid_font->subrmapoffset = cid_font->sdbytes = 0 ; } else { /* No Subrs, look for SubrMap details. We don't enforce requiring the offsets if there is no SubrCount or it is zero. */ cid_font->subrs = NULL ; if ( (theo = mch_private[mch_private_SubrCount].result) != NULL ) { if ( oInteger(*theo) < 0 ) return error_handler(INVALIDFONT) ; cid_font->subrcount = (uint32)oInteger(*theo) ; } if ( (theo = mch_private[mch_private_SDBytes].result) != NULL ) { if ( oInteger(*theo) < 0 || oInteger(*theo) > 4 ) return error_handler(INVALIDFONT) ; cid_font->sdbytes = (uint32)oInteger(*theo) ; } if ( (theo = mch_private[mch_private_SubrMapOffset].result) != NULL ) { if ( oInteger(*theo) < 0 ) return error_handler(INVALIDFONT) ; cid_font->subrmapoffset = (uint32)oInteger(*theo) ; } } /* No Encoding array. */ theTags(theEncoding(*fontInfo)) = ONULL; /* No charstring dictionary. */ theCharStrings(*fontInfo) = NULL; /* Metrics dictionary will be inherited from the top level CIDFont, so don't do anything with theMetrics and theMetrics2. */ /* Test if it's a Morisawa or ATL encypted CID font */ isEncrypted(*fontInfo) = PROTECTED_NONE ; theo = mch_private[mch_private_RunInt].result; if ( theo ) { if ( oName(*theo) == &system_names[ NAME_SpecialRun ] ) isEncrypted(*fontInfo) = PROTECTED_MRSWA ; else if ( oName(*theo) == &system_names[ NAME_eCCRun ] ) isEncrypted(*fontInfo) = PROTECTED_ATL ; } theSubsCount(*fontInfo) = 0; if ( !is_matrix(mch_subdict[mch_subdict_FontMatrix].result, &matrix) ) return FALSE; /* Multiply this by the current fontmatrix to give a new one */ matrix_mult(&matrix, &theFontMatrix(*fontInfo), &theFontMatrix(*fontInfo)); matrix_mult(&matrix, &theFontCompositeMatrix(*fontInfo), &theFontCompositeMatrix(*fontInfo)); /* gotFontMatrix is still set, from the set_font call preceding this. Leave theLookupFont set if it was already, since the FID in the parent dictionary is still valid. The matrix has changed though, so clear the lookup matrix. */ theLookupMatrix(*fontInfo) = NULL ; /* Finally, install the FDArray subdict as the source for Private information */ Copy(&fontInfo->subfont, dict) ; return TRUE; }
int display(list<string>::iterator &ifname, bool signd, bool load, list<string> *mats) { //cout << "displaying " << ifname->c_str() << endl; // conf mode if (conf) return display_net<T>(ifname, signd, load, mats); // mat mode if (is_matrix(ifname->c_str())) { idxdim d = get_matrix_dims(ifname->c_str()); if (interleaved) d.shift_dim(0, 2); if (save_individually || print || !(d.order() == 2 || (d.order() == 3 && (d.dim(2) == 1 || d.dim(2) == 3)))) { // this is probably not an image, just display info and print matrix string type; get_matrix_type(ifname->c_str(), type); idx<T> m = load_matrix<T>(ifname->c_str()); cout << "Matrix " << ifname->c_str() << " is of type " << type << " with dimensions " << d << " (min " << idx_min(m) << ", max " << idx_max(m) << ", mean " << idx_mean(m) << "):" << endl; m.print(); if (has_multiple_matrices(ifname->c_str())) { midx<T> ms = load_matrices<T>(ifname->c_str(), true); // saving sub-matrices if (save_individually) { cout << "Saving each sub-matrix of " << *ifname << " individually..." << endl; save_matrices_individually(ms, *ifname, true); } // printing sub-matrices cout << "This file contains " << m << " matrices: "; if (ms.order() == 1) { for (intg i = 0; i < ms.dim(0); ++i) { idx<T> tmp = ms.mget(i); cout << tmp.info() << " "; } } else if (ms.order() == 2) { for (intg i = 0; i < ms.dim(0); ++i) { for (intg j = 0; j < ms.dim(1); ++j) { idx<T> tmp = ms.mget(i, j); cout << tmp.info() << " "; } cout << endl; } } cout << endl; } else cout << "This is a single-matrix file." << endl; return 0; } } // image mode int loaded = 0; static idx<T> mat; uint h = 0, w = 0, rowh = 0, maxh = 0; list<string>::iterator fname = ifname; #ifdef __GUI__ disable_window_updates(); clear_window(); if (show_filename) { gui << at(h, w) << black_on_white() << ifname->c_str(); h += 16; } #endif maxh = h; for (uint i = 0; i < nh; ++i) { rowh = maxh; for (uint j = 0; j < nw; ++j) { if (fname == mats->end()) fname = mats->begin(); try { // if (load) mat = load_image<T>(*fname); if (print) cout << *fname << ": " << mat << endl << mat.str() << endl; // show only some channels if (chans >= 0) mat = mat.select(2, chans); loaded++; maxh = (std::max)(maxh, (uint) (rowh + mat.dim(0))); T min = 0, max = 0; #ifdef __GUI__ if (autorange || signd) { if (autorange) { min = idx_min(mat); max = idx_max(mat); } else if (signd) { T matmin = idx_min(mat); if ((double)matmin < 0) { min = -1; max = -1; } } draw_matrix(mat, rowh, w, zoom, zoom, min, max); } else draw_matrix(mat, rowh, w, zoom, zoom, (T) range[0], (T) range[1]); #endif w += mat.dim(1) + 1; } catch(string &err) { ERROR_MSG(err.c_str()); } fname++; if (fname == ifname) break ; } if (fname == ifname) break ; maxh++; w = 0; } #ifdef __GUI__ // info if (show_info) { set_text_colors(0, 0, 0, 255, 255, 255, 255, 200); gui << mat; gui << at(15, 0) << *fname; gui << at(29, 0) << "min: " << idx_min(mat) << " max: " << idx_max(mat); } // help if (show_help) { h = 0; w = 0; uint hstep = 14; set_text_colors(0, 0, 255, 255, 255, 255, 255, 200); gui << at(h, w) << "Controls:"; h += hstep; set_text_colors(0, 0, 0, 255, 255, 255, 255, 200); gui << at(h, w) << "Right/Space: next image"; h += hstep; gui << at(h, w) << "Left/Backspace: previous image"; h += hstep; gui << at(h, w) << "i: image info"; h += hstep; gui << at(h, w) << "a: auto-range (use min and max as range)"; h += hstep; gui << at(h, w) << "x/z: show more/less images on width axis"; h += hstep; gui << at(h, w) << "y/t: show more/less images on height axis"; h += hstep; gui << at(h, w) << "0,1,2: show channel 0, 1 or 2 only"; h += hstep; gui << at(h, w) << "9: show alls channels"; h += hstep; gui << at(h, w) << "h: help"; } // update title string title; title << "matshow: " << ebl::basename(ifname->c_str()); set_window_title(title.c_str()); enable_window_updates(); #endif return loaded; }