int test_prod(Epsilon const& epsilon) { int ret; viennacl::tools::uniform_random_numbers<NumericT> randomNumber; std::size_t matrix_size1 = 29; //some odd number, not too large std::size_t matrix_size2 = 47; //some odd number, not too large std::size_t matrix_size3 = 33; //some odd number, not too large //std::size_t matrix_size1 = 128; //some odd number, not too large //std::size_t matrix_size2 = 64; //some odd number, not too large //std::size_t matrix_size3 = 128; //some odd number, not too large //std::size_t matrix_size1 = 256; // for testing AMD kernels //std::size_t matrix_size2 = 256; // for testing AMD kernels //std::size_t matrix_size3 = 256; // for testing AMD kernels // -------------------------------------------------------------------------- // ublas reference: std::vector<std::vector<NumericT> > A(matrix_size1, std::vector<NumericT>(matrix_size2)); std::vector<std::vector<NumericT> > big_A(4*matrix_size1, std::vector<NumericT>(4*matrix_size2, NumericT(3.1415))); std::vector<std::vector<NumericT> > B(matrix_size2, std::vector<NumericT>(matrix_size3)); std::vector<std::vector<NumericT> > big_B(4*matrix_size2, std::vector<NumericT>(4*matrix_size3, NumericT(42.0))); std::vector<std::vector<NumericT> > C(matrix_size1, std::vector<NumericT>(matrix_size3)); //fill A and B: for (std::size_t i = 0; i < A.size(); ++i) for (std::size_t j = 0; j < A[0].size(); ++j) A[i][j] = static_cast<NumericT>(0.1) * randomNumber(); for (std::size_t i = 0; i < B.size(); ++i) for (std::size_t j = 0; j < B[0].size(); ++j) B[i][j] = static_cast<NumericT>(0.1) * randomNumber(); std::vector<std::vector<NumericT> > A_trans(A[0].size(), std::vector<NumericT>(A.size())); for (std::size_t i = 0; i < A.size(); ++i) for (std::size_t j = 0; j < A[0].size(); ++j) A_trans[j][i] = A[i][j]; std::vector<std::vector<NumericT> > big_A_trans(big_A[0].size(), std::vector<NumericT>(big_A.size())); for (std::size_t i = 0; i < big_A.size(); ++i) for (std::size_t j = 0; j < big_A[0].size(); ++j) big_A_trans[j][i] = big_A[i][j]; std::vector<std::vector<NumericT> > B_trans(B[0].size(), std::vector<NumericT>(B.size())); for (std::size_t i = 0; i < B.size(); ++i) for (std::size_t j = 0; j < B[0].size(); ++j) B_trans[j][i] = B[i][j]; std::vector<std::vector<NumericT> > big_B_trans(big_B[0].size(), std::vector<NumericT>(big_B.size())); for (std::size_t i = 0; i < big_B.size(); ++i) for (std::size_t j = 0; j < big_B[0].size(); ++j) big_B_trans[j][i] = big_B[i][j]; // // ViennaCL objects // // A viennacl::range range1_A(matrix_size1, 2*matrix_size1); viennacl::range range2_A(matrix_size2, 2*matrix_size2); viennacl::slice slice1_A(matrix_size1, 2, matrix_size1); viennacl::slice slice2_A(matrix_size2, 3, matrix_size2); viennacl::matrix<NumericT, F_A> vcl_A(matrix_size1, matrix_size2); viennacl::copy(A, vcl_A); viennacl::matrix<NumericT, F_A> vcl_big_range_A(4*matrix_size1, 4*matrix_size2); viennacl::matrix_range<viennacl::matrix<NumericT, F_A> > vcl_range_A(vcl_big_range_A, range1_A, range2_A); viennacl::copy(A, vcl_range_A); viennacl::matrix<NumericT, F_A> vcl_big_slice_A(4*matrix_size1, 4*matrix_size2); viennacl::matrix_slice<viennacl::matrix<NumericT, F_A> > vcl_slice_A(vcl_big_slice_A, slice1_A, slice2_A); viennacl::copy(A, vcl_slice_A); // A^T viennacl::matrix<NumericT, F_A> vcl_A_trans(matrix_size2, matrix_size1); viennacl::copy(A_trans, vcl_A_trans); viennacl::matrix<NumericT, F_A> vcl_big_range_A_trans(4*matrix_size2, 4*matrix_size1); viennacl::matrix_range<viennacl::matrix<NumericT, F_A> > vcl_range_A_trans(vcl_big_range_A_trans, range2_A, range1_A); viennacl::copy(A_trans, vcl_range_A_trans); viennacl::matrix<NumericT, F_A> vcl_big_slice_A_trans(4*matrix_size2, 4*matrix_size1); viennacl::matrix_slice<viennacl::matrix<NumericT, F_A> > vcl_slice_A_trans(vcl_big_slice_A_trans, slice2_A, slice1_A); viennacl::copy(A_trans, vcl_slice_A_trans); // B viennacl::range range1_B(2*matrix_size2, 3*matrix_size2); viennacl::range range2_B(2*matrix_size3, 3*matrix_size3); viennacl::slice slice1_B(matrix_size2, 3, matrix_size2); viennacl::slice slice2_B(matrix_size3, 2, matrix_size3); viennacl::matrix<NumericT, F_B> vcl_B(matrix_size2, matrix_size3); viennacl::copy(B, vcl_B); viennacl::matrix<NumericT, F_B> vcl_big_range_B(4*matrix_size2, 4*matrix_size3); viennacl::matrix_range<viennacl::matrix<NumericT, F_B> > vcl_range_B(vcl_big_range_B, range1_B, range2_B); viennacl::copy(B, vcl_range_B); viennacl::matrix<NumericT, F_B> vcl_big_slice_B(4*matrix_size2, 4*matrix_size3); viennacl::matrix_slice<viennacl::matrix<NumericT, F_B> > vcl_slice_B(vcl_big_slice_B, slice1_B, slice2_B); viennacl::copy(B, vcl_slice_B); // B^T viennacl::matrix<NumericT, F_B> vcl_B_trans(matrix_size3, matrix_size2); viennacl::copy(B_trans, vcl_B_trans); viennacl::matrix<NumericT, F_B> vcl_big_range_B_trans(4*matrix_size3, 4*matrix_size2); viennacl::matrix_range<viennacl::matrix<NumericT, F_B> > vcl_range_B_trans(vcl_big_range_B_trans, range2_B, range1_B); viennacl::copy(B_trans, vcl_range_B_trans); viennacl::matrix<NumericT, F_B> vcl_big_slice_B_trans(4*matrix_size3, 4*matrix_size2); viennacl::matrix_slice<viennacl::matrix<NumericT, F_B> > vcl_slice_B_trans(vcl_big_slice_B_trans, slice2_B, slice1_B); viennacl::copy(B_trans, vcl_slice_B_trans); // C viennacl::range range1_C(matrix_size1-1, 2*matrix_size1-1); viennacl::range range2_C(matrix_size3-1, 2*matrix_size3-1); viennacl::slice slice1_C(matrix_size1-1, 3, matrix_size1); viennacl::slice slice2_C(matrix_size3-1, 3, matrix_size3); viennacl::matrix<NumericT, F_C> vcl_C(matrix_size1, matrix_size3); viennacl::matrix<NumericT, F_C> vcl_big_range_C(4*matrix_size1, 4*matrix_size3); viennacl::matrix_range<viennacl::matrix<NumericT, F_C> > vcl_range_C(vcl_big_range_C, range1_C, range2_C); viennacl::matrix<NumericT, F_C> vcl_big_slice_C(4*matrix_size1, 4*matrix_size3); viennacl::matrix_slice<viennacl::matrix<NumericT, F_C> > vcl_slice_C(vcl_big_slice_C, slice1_C, slice2_C); std::cout << "--- Part 1: Testing matrix-matrix products ---" << std::endl; ////// ////// A: matrix ////// // // std::cout << "Now using A=matrix, B=matrix, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_B, vcl_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=matrix, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_B, vcl_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=matrix, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_B, vcl_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=range, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_range_B, vcl_range_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=range, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_range_B, vcl_range_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=range, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_range_B, vcl_range_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=slice, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=slice, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=matrix, B=slice, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_A, vcl_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; ////// ////// A: range ////// // // std::cout << "Now using A=range, B=matrix, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_B, vcl_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=matrix, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_B, vcl_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=matrix, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_B, vcl_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=range, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_range_B, vcl_range_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=range, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_range_B, vcl_range_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=range, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_range_B, vcl_range_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=slice, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=slice, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=range, B=slice, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_range_A, vcl_range_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; ////// ////// A: slice ////// // // std::cout << "Now using A=slice, B=matrix, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_B, vcl_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=matrix, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_B, vcl_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=matrix, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_B, vcl_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=range, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_range_B, vcl_range_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=range, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_range_B, vcl_range_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=range, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_range_B, vcl_range_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=slice, C=matrix" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=slice, C=range" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_range_C); if (ret != EXIT_SUCCESS) return ret; // // std::cout << "Now using A=slice, B=slice, C=slice" << std::endl; ret = test_prod<NumericT>(epsilon, A, A_trans, B, B_trans, C, vcl_slice_A, vcl_slice_A_trans, vcl_slice_B, vcl_slice_B_trans, vcl_slice_C); if (ret != EXIT_SUCCESS) return ret; return ret; }
LinearSolver::Status_Sol CtcPolytopeHull::run_simplex(IntervalVector& box, LinearSolver::Sense sense, int var, Interval& obj, double bound) { int nvar=nb_var; int nctr=mylinearsolver->getNbRows(); // the linear solver is always called in a minimization mode : in case of maximization of var , the opposite of var is minimized if(sense==LinearSolver::MINIMIZE) mylinearsolver->setVarObj(var, 1.0); else mylinearsolver->setVarObj(var, -1.0); // mylinearsolver->writeFile("coucou.lp"); // system("cat coucou.lp"); LinearSolver::Status_Sol stat = mylinearsolver->solve(); // cout << " stat solver " << stat << endl; if(stat == LinearSolver::OPTIMAL) { if( ((sense==LinearSolver::MINIMIZE) && ( mylinearsolver->getObjValue() <=bound)) || ((sense==LinearSolver::MAXIMIZE) && ((-mylinearsolver->getObjValue())>=bound))) { stat = LinearSolver::UNKNOWN; } } // Neumaier - Shcherbina postprocessing if(stat == LinearSolver::OPTIMAL) { // the dual solution : used to compute the bound Vector dual_solution(mylinearsolver->getNbRows()); LinearSolver::Status stat_dual = mylinearsolver->getDualSol(dual_solution); Matrix A_trans (nb_var,mylinearsolver->getNbRows()) ; LinearSolver::Status stat_A = mylinearsolver->getCoefConstraint_trans(A_trans); /* IntervalMatrix IA_trans (nb_var,mylinearsolver->getNbRows()); for (int i=0;i<nvar; i++){ for(int j=0; j<nctr; j++) IA_trans[i][j]= A_trans[i][j]; }*/ IntervalVector B(mylinearsolver->getNbRows()); LinearSolver::Status stat_B = mylinearsolver->getB(B); bool minimization=false; if (sense==LinearSolver::MINIMIZE) minimization=true; // cout << "B " << B << endl; // cout << "A_trans " << IA_trans << endl; if ((stat_dual==LinearSolver::OK) && (stat_A==LinearSolver::OK) && (stat_B==LinearSolver::OK)) NeumaierShcherbina_postprocessing( mylinearsolver->getNbRows(), var, obj, box, A_trans, B, dual_solution, minimization); else stat = LinearSolver::UNKNOWN; } // infeasibility test cf Neumaier Shcherbina paper if(stat == LinearSolver::INFEASIBLE_NOTPROVED) { Vector infeasible_dir(mylinearsolver->getNbRows()); LinearSolver::Status stat1 = mylinearsolver->getInfeasibleDir(infeasible_dir); Matrix A_trans (nb_var,mylinearsolver->getNbRows()) ; LinearSolver::Status stat2 = mylinearsolver->getCoefConstraint_trans(A_trans); IntervalVector B(mylinearsolver->getNbRows()); LinearSolver::Status stat3 = mylinearsolver->getB(B); if ((stat1==LinearSolver::OK) && (stat2==LinearSolver::OK) && (stat3==LinearSolver::OK) && (NeumaierShcherbina_infeasibilitytest (mylinearsolver->getNbRows(), box, A_trans, B, infeasible_dir))) { stat = LinearSolver::INFEASIBLE; } } // Reset the objective of the LP solver mylinearsolver->setVarObj(var, 0.0); return stat; }