int main(int argc, char **argv, char **envp) { int ** matriz_adj = NULL; int N; int i; if (argc != 2) { printUsage(); exit(1); } if (strlen(argv[1]) < 4 || strcmp(argv[1] + strlen(argv[1]) - 4, ".adj") != 0) { printUsage(); exit(1); } if (readMatrixFromFile(argv[1], &matriz_adj, &N)) { printf("Erro na leitura da matriz do ficheiro!!!\n"); exit(3); } printf("Densidade do grafo: %.4f\n", getGraphDensity(matriz_adj, N)); printf("Grau maximo do grafo: %d\n", getGraphHighRank(matriz_adj, N)); writeMatrixToFile(argv[1], matriz_adj, N); for (i=0;i<N;i++) free(matriz_adj[i]); free(matriz_adj); return 0; }
int main(int argc, char** argv) { Matrix *m1 = NULL, *m2 = NULL, *resultSequential = NULL, *resultParallel = NULL; int numParallelTasks = 1; struct timeval diff; checkArgsSize(argc); m1 = readMatrixFromFile(M1); m2 = readMatrixFromFile(M2); checkInputMatrices(m1, m2); checkNumTasks(argv, &numParallelTasks, m1); diff = measureBalanceWork(m1, m2, numParallelTasks, &resultParallel, balanceWork); writeMatrixInFile(OUT, resultParallel); printTime("Tempo levado para executar a multiplicação com %d threads: ", numParallelTasks, diff); pthread_exit(NULL); }
int readTwoOnDimMatrixFromAFile(char *fileName , oneDimMatrix * a , oneDimMatrix * b){ FILE *fp; int numberOfLines = 0; fp = openAFileForReading(fileName); numberOfLines = readMatrixFromFile(fp, numberOfLines, DETECT_SIZE, a); printf("%d %d %d \n" ,numberOfLines , a->nrows , a->ncols ); numberOfLines= readMatrixFromFile(fp, numberOfLines, DETECT_SIZE , b); printf("%d %d %d \n" ,numberOfLines , b->nrows , b->ncols); if(a->nrows != b->nrows) inconsistentErrorReport("Different number of rows in each matrix.", numberOfLines, a->nrows , a->ncols); fclose(fp); *a = createMatrix(a->nrows , a->ncols); *b = createMatrix(b->nrows , b->ncols); fp = openAFileForReading(fileName); numberOfLines = readMatrixFromFile(fp, numberOfLines, READ_MATRIX, a); numberOfLines= readMatrixFromFile(fp, numberOfLines, READ_MATRIX , b); fclose(fp); /* printOneDimMatrix(a); printf("\n"); printOneDimMatrix(b); */ return numberOfLines; }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) { thread = new QThread(); reader = new Reader(); reader->moveToThread(thread); connect(reader, SIGNAL(sendPoint(int,int,double)), this, SLOT(setPointProb(int,int,double))); connect(reader, SIGNAL(workRequested()), thread, SLOT(start())); connect(thread, SIGNAL(started()), reader, SLOT(doWork())); connect(reader, SIGNAL(finished()), thread, SLOT(quit()) , Qt::DirectConnection); connect(reader, SIGNAL(finished()), this, SLOT(fileFinished())); connect(reader, SIGNAL(sendReset()), this, SLOT(resetPositions())); setFixedSize(800,600); p_scene = new QGraphicsScene(this); p_view = new QGraphicsView(p_scene, this); QPixmap background(QCoreApplication::applicationDirPath() + "/img/sol.png"); if (background.isNull()) { std::cout << "Ouverture de sol.png échouée, ouverture de sol.jpg" << std::endl; background = QPixmap(QCoreApplication::applicationDirPath() + "/img/sol.jpg"); } p_scene->setBackgroundBrush(QBrush(background)); p_view->setGeometry(10,10,505,505); p_addPosition = new QPushButton("Ajouter position", this); p_addPosition->setGeometry(590,90, 120, 30); p_deletePos = new QPushButton("Réinitialiser positions", this); p_deletePos->setGeometry(590,130, 120, 30); p_openFile = new QPushButton("Ouvrir fichier", this); p_openFile->setGeometry(590, 170, 120, 30); p_changeTableSize = new QPushButton("Changer taille table", this); p_changeTableSize->setGeometry(50, 560, 120, 30); pauseButton = new QPushButton("", this); QIcon pauseIcon(QCoreApplication::applicationDirPath() + "/img/pause.png"); if (pauseIcon.isNull()) { std::cout << "Ouverture de pause.png échouée, ouverture de pause.jpg" << std::endl; pauseIcon = QIcon((QCoreApplication::applicationDirPath() + "/img/pause.jpg")); } pauseButton->setIcon(pauseIcon); pauseButton->setGeometry(590, 250, 30, 30); pauseButton->setDisabled(true); stopButton = new QPushButton("", this); QIcon stopIcon(QCoreApplication::applicationDirPath() + "/img/stop.png"); if (stopIcon.isNull()) { std::cout << "Ouverture de stop.png échouée, ouverture de stop.jpg" << std::endl; pauseIcon = QIcon((QCoreApplication::applicationDirPath() + "/img/stop.jpg")); } stopButton->setIcon(stopIcon); stopButton->setGeometry(630, 250, 30, 30); stopButton->setDisabled(true); stepButton = new QPushButton("", this); QIcon stepIcon(QCoreApplication::applicationDirPath() + "/img/step.png"); if (stepIcon.isNull()) { std::cout << "Ouverture de step.png échouée, ouverture de step.jpg" << std::endl; stepIcon = QIcon((QCoreApplication::applicationDirPath() + "/img/step.jpg")); } stepButton->setIcon(stepIcon); stepButton->setGeometry(670, 250, 30, 30); stepButton->setDisabled(true); p_quit = new QPushButton("Quitter", this); p_quit->setGeometry(600, 560, 100, 30); p_addPosX = new QLineEdit(this); p_addPosY = new QLineEdit(this); p_addPosP = new QLineEdit(this); p_addPosX->setGeometry(580, 50, 40, 30); p_addPosY->setGeometry(630, 50, 40, 30); p_addPosP->setGeometry(680, 50, 40, 30); p_addPosX->setPlaceholderText("Abscisse"); p_addPosY->setPlaceholderText("Ordonnée"); p_addPosP->setPlaceholderText("Proba"); currentDate = new QLabel("Pas de fichier en cours", this); currentDate->setGeometry(580, 300, 140, 30); QObject::connect(p_addPosition, SIGNAL(clicked()), this, SLOT(sendPointProbValues())); QObject::connect(this, SIGNAL(pointProbValues(int,int,double)), this, SLOT(setPointProb(int,int,double))); QObject::connect(p_deletePos, SIGNAL(clicked()), this, SLOT(resetPositions())); QObject::connect(p_quit, SIGNAL(clicked()), qApp, SLOT(quit())); QObject::connect(p_openFile, SIGNAL(clicked()), this, SLOT(readMatrixFromFile())); QObject::connect(p_changeTableSize, SIGNAL(clicked()), this, SLOT(changeTableSize())); QObject::connect(pauseButton, SIGNAL(clicked()), this, SLOT(pauseRead())); QObject::connect(stopButton, SIGNAL(clicked()), this, SLOT(stopRead())); QObject::connect(reader, SIGNAL(sendDate(QString)), this, SLOT(setDate(QString))); QObject::connect(stepButton, SIGNAL(clicked()), this, SLOT(clickNextDate())); }
void pcl::face_detection::FaceDetectorDataProvider<FeatureType, DataSet, LabelType, ExampleIndex, NodeType>::initialize(std::string & data_dir) { std::string start; std::string ext = std::string ("pcd"); bf::path dir = data_dir; std::vector < std::string > files; getFilesInDirectory (dir, start, files, ext); //apart from loading the file names, we will do some bining regarding pitch and yaw std::vector < std::vector<int> > yaw_pitch_bins; std::vector < std::vector<std::vector<std::string> > > image_files_per_bin; float res_yaw = 15.f; float res_pitch = res_yaw; int min_yaw = -75; int min_pitch = -60; int num_yaw = static_cast<int>((std::abs (min_yaw) * 2) / static_cast<int>(res_yaw + 1.f)); int num_pitch = static_cast<int>((std::abs (min_pitch) * 2) / static_cast<int>(res_pitch + 1.f)); yaw_pitch_bins.resize (num_yaw); image_files_per_bin.resize (num_yaw); for (int i = 0; i < num_yaw; i++) { yaw_pitch_bins[i].resize (num_pitch); image_files_per_bin[i].resize (num_pitch); for (int j = 0; j < num_pitch; j++) { yaw_pitch_bins[i][j] = 0; } } for (size_t i = 0; i < files.size (); i++) { std::stringstream filestream; filestream << data_dir << "/" << files[i]; std::string file = filestream.str (); std::string pose_file (files[i]); boost::replace_all (pose_file, ".pcd", "_pose.txt"); Eigen::Matrix4f pose_mat; pose_mat.setIdentity (4, 4); std::stringstream filestream_pose; filestream_pose << data_dir << "/" << pose_file; pose_file = filestream_pose.str (); bool result = readMatrixFromFile (pose_file, pose_mat); if (result) { Eigen::Vector3f ea = pose_mat.block<3, 3> (0, 0).eulerAngles (0, 1, 2); ea *= 57.2957795f; //transform it to degrees to do the binning int y = static_cast<int>(pcl_round ((ea[0] + static_cast<float>(std::abs (min_yaw))) / res_yaw)); int p = static_cast<int>(pcl_round ((ea[1] + static_cast<float>(std::abs (min_pitch))) / res_pitch)); if (y < 0) y = 0; if (p < 0) p = 0; if (p >= num_pitch) p = num_pitch - 1; if (y >= num_yaw) y = num_yaw - 1; assert (y >= 0 && y < num_yaw); assert (p >= 0 && p < num_pitch); yaw_pitch_bins[y][p]++; image_files_per_bin[y][p].push_back (file); } } pcl::face_detection::showBining (num_pitch, res_pitch, min_pitch, num_yaw, res_yaw, min_yaw, yaw_pitch_bins); int max_elems = 0; int total_elems = 0; for (int i = 0; i < num_yaw; i++) { for (int j = 0; j < num_pitch; j++) { total_elems += yaw_pitch_bins[i][j]; if (yaw_pitch_bins[i][j] > max_elems) max_elems = yaw_pitch_bins[i][j]; } } float average = static_cast<float> (total_elems) / (static_cast<float> (num_pitch + num_yaw)); std::cout << "The average number of image per bin is:" << average << std::endl; std::cout << "Total number of images in the dataset:" << total_elems << std::endl; //reduce unbalance from dataset by capping the number of images per bin, keeping at least a certain min if (min_images_per_bin_ != -1) { std::cout << "Reducing unbalance of the dataset." << std::endl; for (int i = 0; i < num_yaw; i++) { for (int j = 0; j < num_pitch; j++) { if (yaw_pitch_bins[i][j] >= min_images_per_bin_) { std::random_shuffle (image_files_per_bin[i][j].begin (), image_files_per_bin[i][j].end ()); image_files_per_bin[i][j].resize (min_images_per_bin_); yaw_pitch_bins[i][j] = min_images_per_bin_; } for (size_t ii = 0; ii < image_files_per_bin[i][j].size (); ii++) { image_files_.push_back (image_files_per_bin[i][j][ii]); } } } } pcl::face_detection::showBining (num_pitch, res_pitch, min_pitch, num_yaw, res_yaw, min_yaw, yaw_pitch_bins); std::cout << "Total number of images in the dataset:" << image_files_.size () << std::endl; }
void pcl::face_detection::FaceDetectorDataProvider<FeatureType, DataSet, LabelType, ExampleIndex, NodeType>::getDatasetAndLabels(DataSet & data_set, std::vector<LabelType> & label_data, std::vector<ExampleIndex> & examples) { srand (static_cast<unsigned int>(time (NULL))); std::random_shuffle (image_files_.begin (), image_files_.end ()); std::vector < std::string > files; files = image_files_; files.resize (std::min (num_images_, static_cast<int> (files.size ()))); std::vector < TrainingExample > training_examples; std::vector<float> labels; int total_neg, total_pos; total_neg = total_pos = 0; #if PCL_FACE_DETECTION_VIS_TRAINING_FDDP == 1 pcl::visualization::PCLVisualizer vis("training"); #endif for (size_t j = 0; j < files.size (); j++) { #if PCL_FACE_DETECTION_VIS_TRAINING_FDDP == 1 vis.removeAllPointClouds(); vis.removeAllShapes(); #endif if ((j % 50) == 0) { std::cout << "Loading image..." << j << std::endl; } //1. Load clouds with and without labels pcl::PointCloud<pcl::PointXYZ>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZ>); pcl::PointCloud<pcl::PointXYZ>::Ptr loaded_cloud (new pcl::PointCloud<pcl::PointXYZ>); pcl::io::loadPCDFile (files[j], *loaded_cloud); pcl::PointCloud<pcl::PointXYZL>::Ptr cloud_labels (new pcl::PointCloud<pcl::PointXYZL>); pcl::PointCloud<pcl::PointXYZL>::Ptr loaded_cloud_labels (new pcl::PointCloud<pcl::PointXYZL>); pcl::io::loadPCDFile (files[j], *loaded_cloud_labels); //crop images to remove as many NaNs as possible and reduce the memory footprint { size_t min_col, min_row; size_t max_col, max_row; min_col = min_row = std::numeric_limits<size_t>::max (); max_col = max_row = 0; for (size_t col = 0; col < loaded_cloud->width; col++) { for (size_t row = 0; row < loaded_cloud->height; row++) { if (pcl::isFinite (loaded_cloud->at (col, row))) { if (row < min_row) min_row = row; if (row > max_row) max_row = row; if (col < min_col) min_col = col; if (col > max_col) max_col = col; } } } //std::cout << min_col << " - " << max_col << std::endl; //std::cout << min_row << " - " << max_row << std::endl; cropCloud<pcl::PointXYZ> (min_col, max_col, min_row, max_row, *loaded_cloud, *cloud); cropCloud<pcl::PointXYZL> (min_col, max_col, min_row, max_row, *loaded_cloud_labels, *cloud_labels); /*pcl::visualization::PCLVisualizer vis ("training"); vis.addPointCloud(loaded_cloud); vis.spin();*/ } //Compute integral image over depth boost::shared_ptr < pcl::IntegralImage2D<float, 1> > integral_image_depth; integral_image_depth.reset (new pcl::IntegralImage2D<float, 1> (false)); int element_stride = sizeof(pcl::PointXYZ) / sizeof(float); int row_stride = element_stride * cloud->width; const float *data = reinterpret_cast<const float*> (&cloud->points[0]); integral_image_depth->setInput (data + 2, cloud->width, cloud->height, element_stride, row_stride); //Compute normals and normal integral images pcl::PointCloud<pcl::Normal>::Ptr normals (new pcl::PointCloud<pcl::Normal>); if (USE_NORMALS_) { typedef typename pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> NormalEstimator_; NormalEstimator_ n3d; n3d.setNormalEstimationMethod (n3d.COVARIANCE_MATRIX); n3d.setInputCloud (cloud); n3d.setRadiusSearch (0.02); n3d.setKSearch (0); { pcl::ScopeTime t ("compute normals..."); n3d.compute (*normals); } } int element_stride_normal = sizeof(pcl::Normal) / sizeof(float); int row_stride_normal = element_stride_normal * normals->width; boost::shared_ptr < pcl::IntegralImage2D<float, 1> > integral_image_normal_x; boost::shared_ptr < pcl::IntegralImage2D<float, 1> > integral_image_normal_y; boost::shared_ptr < pcl::IntegralImage2D<float, 1> > integral_image_normal_z; if (USE_NORMALS_) { integral_image_normal_x.reset (new pcl::IntegralImage2D<float, 1> (false)); const float *data_nx = reinterpret_cast<const float*> (&normals->points[0]); integral_image_normal_x->setInput (data_nx, normals->width, normals->height, element_stride_normal, row_stride_normal); integral_image_normal_y.reset (new pcl::IntegralImage2D<float, 1> (false)); const float *data_ny = reinterpret_cast<const float*> (&normals->points[0]); integral_image_normal_y->setInput (data_ny + 1, normals->width, normals->height, element_stride_normal, row_stride_normal); integral_image_normal_z.reset (new pcl::IntegralImage2D<float, 1> (false)); const float *data_nz = reinterpret_cast<const float*> (&normals->points[0]); integral_image_normal_z->setInput (data_nz + 2, normals->width, normals->height, element_stride_normal, row_stride_normal); } //Using cloud labels estimate a 2D window from where to extract positive samples //Rest can be used to extract negative samples size_t min_col, min_row; size_t max_col, max_row; min_col = min_row = std::numeric_limits<size_t>::max (); max_col = max_row = 0; //std::cout << cloud_labels->width << " " << cloud_labels->height << std::endl; for (size_t col = 0; col < cloud_labels->width; col++) { for (size_t row = 0; row < cloud_labels->height; row++) { if (cloud_labels->at (col, row).label == 1) { if (row < min_row) min_row = row; if (row > max_row) max_row = row; if (col < min_col) min_col = col; if (col > max_col) max_col = col; } } } #if PCL_FACE_DETECTION_VIS_TRAINING_FDDP == 1 pcl::PointCloud<pcl::PointXYZI>::Ptr cloud_intensity(new pcl::PointCloud<pcl::PointXYZI>); cloud_intensity->width = cloud->width; cloud_intensity->height = cloud->height; cloud_intensity->points.resize(cloud->points.size()); cloud_intensity->is_dense = cloud->is_dense; for (int jjj = 0; jjj < static_cast<int>(cloud->points.size()); jjj++) { cloud_intensity->points[jjj].getVector4fMap() = cloud->points[jjj].getVector4fMap(); cloud_intensity->points[jjj].intensity = 0.f; int row, col; col = jjj % cloud->width; row = jjj / cloud->width; //std::cout << row << " " << col << std::endl; if (check_inside(col, row, min_col, max_col, min_row, max_row)) { cloud_intensity->points[jjj].intensity = 1.f; } } pcl::visualization::PointCloudColorHandlerGenericField < pcl::PointXYZI > handler(cloud_intensity, "intensity"); vis.addPointCloud(cloud_intensity, handler, "intensity_cloud"); #endif std::string pose_file (files[j]); boost::replace_all (pose_file, ".pcd", "_pose.txt"); Eigen::Matrix4f pose_mat; pose_mat.setIdentity (4, 4); readMatrixFromFile (pose_file, pose_mat); Eigen::Vector3f ea = pose_mat.block<3, 3> (0, 0).eulerAngles (0, 1, 2); Eigen::Vector3f trans_vector = Eigen::Vector3f (pose_mat (0, 3), pose_mat (1, 3), pose_mat (2, 3)); pcl::PointXYZ center_point; center_point.x = trans_vector[0]; center_point.y = trans_vector[1]; center_point.z = trans_vector[2]; int N_patches = patches_per_image_; int pos_extracted = 0; int neg_extracted = 0; int w_size_2 = static_cast<int> (w_size_ / 2); //************************************************ //2nd training style, fanelli's journal description //************************************************ { typedef std::pair<int, int> pixelpair; std::vector < pixelpair > negative_p, positive_p; //get negative and positive indices to sample from for (int col = 0; col < (static_cast<int> (cloud_labels->width) - w_size_); col++) { for (int row = 0; row < (static_cast<int> (cloud_labels->height) - w_size_); row++) { if (!pcl::isFinite (cloud->at (col + w_size_2, row + w_size_2))) continue; //reject patches with more than percent invalid values float percent = 0.5f; if (static_cast<float>(integral_image_depth->getFiniteElementsCount (col, row, w_size_, w_size_)) < (percent * static_cast<float>(w_size_ * w_size_))) continue; pixelpair pp = std::make_pair (col, row); if (cloud_labels->at (col + w_size_2, row + w_size_2).label == 1) positive_p.push_back (pp); else negative_p.push_back (pp); } } //shuffle and resize std::random_shuffle (positive_p.begin (), positive_p.end ()); std::random_shuffle (negative_p.begin (), negative_p.end ()); positive_p.resize (N_patches); negative_p.resize (N_patches); //extract positive patch for (size_t p = 0; p < positive_p.size (); p++) { int col, row; col = positive_p[p].first; row = positive_p[p].second; pcl::PointXYZ patch_center_point; patch_center_point.x = cloud->at (col + w_size_2, row + w_size_2).x; patch_center_point.y = cloud->at (col + w_size_2, row + w_size_2).y; patch_center_point.z = cloud->at (col + w_size_2, row + w_size_2).z; TrainingExample te; te.iimages_.push_back (integral_image_depth); if (USE_NORMALS_) { te.iimages_.push_back (integral_image_normal_x); te.iimages_.push_back (integral_image_normal_y); te.iimages_.push_back (integral_image_normal_z); } te.row_ = row; te.col_ = col; te.wsize_ = w_size_; te.trans_ = center_point.getVector3fMap () - patch_center_point.getVector3fMap (); te.trans_ *= 1000.f; //transform it to millimeters te.rot_ = ea; te.rot_ *= 57.2957795f; //transform it to degrees labels.push_back (1); pos_extracted++; total_pos++; training_examples.push_back (te); #if PCL_FACE_DETECTION_VIS_TRAINING_FDDP == 1 pcl::PointCloud<pcl::PointXYZI>::Ptr cloud_intensity2(new pcl::PointCloud<pcl::PointXYZI>(*cloud_intensity)); for (int jjj = col; jjj < (col + w_size_); jjj++) { for (int iii = row; iii < (row + w_size_); iii++) { cloud_intensity2->at(jjj, iii).intensity = 2.f; } } vis.removeAllPointClouds(); pcl::visualization::PointCloudColorHandlerGenericField < pcl::PointXYZI > handler(cloud_intensity2, "intensity"); vis.addPointCloud(cloud_intensity2, handler, "cloud"); vis.spinOnce(); vis.spin(); sleep(1); #endif } #if PCL_FACE_DETECTION_VIS_TRAINING_FDDP == 1 std::cout << "Going to extract negative patches..." << std::endl; sleep(2); #endif for (size_t p = 0; p < negative_p.size (); p++) { int col, row; col = negative_p[p].first; row = negative_p[p].second; TrainingExample te; te.iimages_.push_back (integral_image_depth); if (USE_NORMALS_) { te.iimages_.push_back (integral_image_normal_x); te.iimages_.push_back (integral_image_normal_y); te.iimages_.push_back (integral_image_normal_z); } te.row_ = row; te.col_ = col; te.wsize_ = w_size_; labels.push_back (0); neg_extracted++; total_neg++; training_examples.push_back (te); #if PCL_FACE_DETECTION_VIS_TRAINING_FDDP == 1 pcl::PointCloud<pcl::PointXYZI>::Ptr cloud_intensity2(new pcl::PointCloud<pcl::PointXYZI>(*cloud_intensity)); for (int jjj = col; jjj < (col + w_size_); jjj++) { for (int iii = row; iii < (row + w_size_); iii++) { cloud_intensity2->at(jjj, iii).intensity = 2.f; } } vis.removeAllPointClouds(); pcl::visualization::PointCloudColorHandlerGenericField < pcl::PointXYZI > handler(cloud_intensity2, "intensity"); vis.addPointCloud(cloud_intensity2, handler, "cloud"); vis.spinOnce(); vis.spin(); sleep(1); #endif } if (neg_extracted != N_patches) { std::cout << "Extracted " << neg_extracted << " negative patches" << std::endl; std::cout << files[j] << std::endl; } if (pos_extracted != N_patches) { std::cout << "Extracted " << pos_extracted << " positive patches" << std::endl; std::cout << files[j] << std::endl; } } } std::cout << training_examples.size () << " " << labels.size () << " " << total_neg << " " << total_pos << std::endl; //train random forest and make persistent std::vector<int> example_indices; for (size_t i = 0; i < labels.size (); i++) example_indices.push_back (static_cast<int> (i)); label_data = labels; data_set = training_examples; examples = example_indices; }
int main(int argc, char **argv){ double *a; double *b; double temp; int initID = 0; int n=0; //int res; char *name; clock_t t; double time=0.; FILE *input; if (argc==2){ if ( !(n = atoi(argv[1]))){ printf("This is not a moon!\nI need numberz!\n"); return -4; } //n = atoi(argv[1]); //m = atoi(argv[2]); a = new double[n*n]; if (a==NULL){ printf("Failed to allocate memory for matrix A\n"); return -2; } defineMatrixWithFunction(a, n); initID=1; } else if (argc==3){ if ( !(n = atoi(argv[2]))){ printf("This is not a moon!\n"); return -4; } name = argv[1]; //n = atoi(argv[2]); //m = atoi(argv[3]); int size = n*n; a = new double[size]; if (a==NULL){ printf("Failed to allocate memory for matrix A\n"); return -2; } input = fopen(name, "r"); readMatrixFromFile(input, a, n); fclose(input); initID=2; } else{ printf("Usage:\n %s n\n %s file_name n\n", argv[0], argv[0]); return -1; } if (initID==0){ printf("Failed to initialize matrix\n"); delete[] a; return -1; } b = new double[n]; //printMatrix(a, n, n); //temp = someInvariant_ii(a, n); //printf("Sum before step 1:%.2lf\n", temp); t = clock(); qrAlmostUpperTriangle(a, n); //printMatrix(a, n, n); temp = traceMatrix(a, n); printf("Trace after step 1:%.2lf\n", temp); //temp = someInvariant_ii(a, n); //printf("Sum after step 1:%.2lf\n", temp); searchEigenValues(a, b, n); printMatrix(a, n, n); temp = traceMatrix(a, n); printf("Trace after step 2:%.2lf\n", temp); time = (clock()-t)/(double)(CLOCKS_PER_SEC); printf("Total time:\n%.2lf sec\n", time); for (int i=0; i<n; i++){ printf("Value %d: %.4lf\n", i, b[i]); } delete[] a; delete[] b; return 0; }
Matrix::Matrix(std::string name) { //readFromFile(name); readMatrixFromFile(name); }