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;
}
