mirror of
https://github.com/opencv/opencv.git
synced 2026-11-19 07:45:26 -06:00
* core: fix solveLP floating-point drift producing infeasible solutions * core(lpsolver): tighten pivot-eps comment per review (drop issue ref, note cost) * core(lpsolver): snap cancellation noise relative to the operands Replace the fixed 1e-12 cutoff on the whole tableau with a relative test on the subtraction that updates it. A fixed cutoff turns legitimate small data into zeros (right-hand sides around 1e-14 were returned as z = 0), while the relative test removes only results that are within rounding noise of the values being subtracted. Add small_magnitude_data, which fails with the fixed cutoff. * core(lpsolver): snap cancellation noise when restoring objective after Phase I When any constraint has a negative right-hand side, initialize_simplex() runs Phase I and then rebuilds the original objective from old_c and the Phase I tableau before entering Phase II inner_simplex(). Snap cancellation noise in those updates consistently with pivot() so that exact-zero checks in Phase II are not distorted by residual rounding error. Add negative_rhs_restore_cancellation regression test. * core(lpsolver): compare the regression tests with their exact optima issue_12343 has the unique optimum z = (16, 15, 0, 24)/37, objective 189/37. Compare z with it through cvtest::norm, as regression_basic does. Checking only the status and the constraints passes for any feasible point reported as SOLVELP_SINGLE. Compare small_magnitude_data with its exact solution as well, and check that the point returned by negative_rhs_restore_cancellation lies on its optimal segment. Assert the status first in all three tests. Inline add_snap_zero, which had one caller, and drop an example noise magnitude from the sub_snap_zero comment that does not hold in general. * core(lpsolver): pivot the Phase I auxiliary variable out on a nonzero entry When Phase I ends with the auxiliary variable x0 basic at value 0, initialize_simplex() makes it nonbasic by one degenerate pivot. It always pivoted on the first column of x0's row, but that entry can be 0. With cancellation noise snapped to exact zeros this happens often: the pivot divides by 0 and solveLP returns SOLVELP_UNBOUNDED for bounded problems. Pivot on the entry of largest magnitude instead. Add phase1_auxiliary_basic_at_zero, which returned SOLVELP_UNBOUNDED. * core(lpsolver): guard zero Phase I pivot row and snap v updates * core(lpsolver): snap each restored objective coefficient once After Phase I, each coefficient of the original objective is rebuilt as a sum of terms. Add up each column and the absolute values of its terms, and set the coefficient to 0 once, when it is at most 1e-12 times that absolute sum, instead of snapping after every term. The objective value v is never compared or returned, so its updates go back to plain additions. The doc comment of initialize_simplex() now lists SOLVELP_LOST.
219 lines
7.8 KiB
C++
219 lines
7.8 KiB
C++
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
//
|
|
// By downloading, copying, installing or using the software you agree to this license.
|
|
// If you do not agree to this license, do not download, install,
|
|
// copy or use the software.
|
|
//
|
|
//
|
|
// License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
|
|
// Third party copyrights are property of their respective owners.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistribution's in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// * The name of the copyright holders may not be used to endorse or promote products
|
|
// derived from this software without specific prior written permission.
|
|
//
|
|
// This software is provided by the copyright holders and contributors "as is" and
|
|
// any express or implied warranties, including, but not limited to, the implied
|
|
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
|
// In no event shall the OpenCV Foundation or contributors be liable for any direct,
|
|
// indirect, incidental, special, exemplary, or consequential damages
|
|
// (including, but not limited to, procurement of substitute goods or services;
|
|
// loss of use, data, or profits; or business interruption) however caused
|
|
// and on any theory of liability, whether in contract, strict liability,
|
|
// or tort (including negligence or otherwise) arising in any way out of
|
|
// the use of this software, even if advised of the possibility of such damage.
|
|
//
|
|
//M*/
|
|
#include "test_precomp.hpp"
|
|
|
|
namespace opencv_test { namespace {
|
|
|
|
TEST(Core_LPSolver, regression_basic){
|
|
cv::Mat A,B,z,etalon_z;
|
|
|
|
#if 1
|
|
//cormen's example #1
|
|
A=(cv::Mat_<double>(3,1)<<3,1,2);
|
|
B=(cv::Mat_<double>(3,4)<<1,1,3,30,2,2,5,24,4,1,2,36);
|
|
std::cout<<"here A goes\n"<<A<<"\n";
|
|
cv::solveLP(A,B,z);
|
|
std::cout<<"here z goes\n"<<z<<"\n";
|
|
etalon_z=(cv::Mat_<double>(3,1)<<8,4,0);
|
|
ASSERT_LT(cvtest::norm(z, etalon_z, cv::NORM_L1), 1e-12);
|
|
#endif
|
|
|
|
#if 1
|
|
//cormen's example #2
|
|
A=(cv::Mat_<double>(1,2)<<18,12.5);
|
|
B=(cv::Mat_<double>(3,3)<<1,1,20,1,0,20,0,1,16);
|
|
std::cout<<"here A goes\n"<<A<<"\n";
|
|
cv::solveLP(A,B,z);
|
|
std::cout<<"here z goes\n"<<z<<"\n";
|
|
etalon_z=(cv::Mat_<double>(2,1)<<20,0);
|
|
ASSERT_LT(cvtest::norm(z, etalon_z, cv::NORM_L1), 1e-12);
|
|
#endif
|
|
|
|
#if 1
|
|
//cormen's example #3
|
|
A=(cv::Mat_<double>(1,2)<<5,-3);
|
|
B=(cv::Mat_<double>(2,3)<<1,-1,1,2,1,2);
|
|
std::cout<<"here A goes\n"<<A<<"\n";
|
|
cv::solveLP(A,B,z);
|
|
std::cout<<"here z goes\n"<<z<<"\n";
|
|
etalon_z=(cv::Mat_<double>(2,1)<<1,0);
|
|
ASSERT_LT(cvtest::norm(z, etalon_z, cv::NORM_L1), 1e-12);
|
|
#endif
|
|
}
|
|
|
|
TEST(Core_LPSolver, regression_init_unfeasible){
|
|
cv::Mat A,B,z,etalon_z;
|
|
|
|
#if 1
|
|
//cormen's example #4 - unfeasible
|
|
A=(cv::Mat_<double>(1,3)<<-1,-1,-1);
|
|
B=(cv::Mat_<double>(2,4)<<-2,-7.5,-3,-10000,-20,-5,-10,-30000);
|
|
std::cout<<"here A goes\n"<<A<<"\n";
|
|
cv::solveLP(A,B,z);
|
|
std::cout<<"here z goes\n"<<z<<"\n";
|
|
etalon_z=(cv::Mat_<double>(3,1)<<1250,1000,0);
|
|
ASSERT_LT(cvtest::norm(z, etalon_z, cv::NORM_L1), 1e-12);
|
|
#endif
|
|
}
|
|
|
|
TEST(DISABLED_Core_LPSolver, regression_absolutely_unfeasible){
|
|
cv::Mat A,B,z,etalon_z;
|
|
|
|
#if 1
|
|
//trivial absolutely unfeasible example
|
|
A=(cv::Mat_<double>(1,1)<<1);
|
|
B=(cv::Mat_<double>(2,2)<<1,-1);
|
|
std::cout<<"here A goes\n"<<A<<"\n";
|
|
int res=cv::solveLP(A,B,z);
|
|
ASSERT_EQ(res,-1);
|
|
#endif
|
|
}
|
|
|
|
TEST(Core_LPSolver, regression_multiple_solutions){
|
|
cv::Mat A,B,z,etalon_z;
|
|
|
|
#if 1
|
|
//trivial example with multiple solutions
|
|
A=(cv::Mat_<double>(2,1)<<1,1);
|
|
B=(cv::Mat_<double>(1,3)<<1,1,1);
|
|
std::cout<<"here A goes\n"<<A<<"\n";
|
|
int res=cv::solveLP(A,B,z);
|
|
printf("res=%d\n",res);
|
|
printf("scalar %g\n",z.dot(A));
|
|
std::cout<<"here z goes\n"<<z<<"\n";
|
|
ASSERT_EQ(res,1);
|
|
ASSERT_LT(fabs(z.dot(A) - 1), DBL_EPSILON);
|
|
#endif
|
|
}
|
|
|
|
TEST(Core_LPSolver, regression_cycling){
|
|
cv::Mat A,B,z,etalon_z;
|
|
|
|
#if 1
|
|
//example with cycling from http://people.orie.cornell.edu/miketodd/or630/SimplexCyclingExample.pdf
|
|
A=(cv::Mat_<double>(4,1)<<10,-57,-9,-24);
|
|
B=(cv::Mat_<double>(3,5)<<0.5,-5.5,-2.5,9,0,0.5,-1.5,-0.5,1,0,1,0,0,0,1);
|
|
std::cout<<"here A goes\n"<<A<<"\n";
|
|
int res=cv::solveLP(A,B,z);
|
|
printf("res=%d\n",res);
|
|
printf("scalar %g\n",z.dot(A));
|
|
std::cout<<"here z goes\n"<<z<<"\n";
|
|
ASSERT_LT(fabs(z.dot(A) - 1), DBL_EPSILON);
|
|
//ASSERT_EQ(res,1);
|
|
#endif
|
|
}
|
|
|
|
TEST(Core_LPSolver, issue_12337)
|
|
{
|
|
Mat A=(cv::Mat_<double>(3,1)<<3,1,2);
|
|
Mat B=(cv::Mat_<double>(3,4)<<1,1,3,30,2,2,5,24,4,1,2,36);
|
|
Mat1f z_float; cv::solveLP(A, B, z_float);
|
|
Mat1d z_double; cv::solveLP(A, B, z_double);
|
|
Mat1i z_int; cv::solveLP(A, B, z_int);
|
|
EXPECT_ANY_THROW(Mat1b z_8u; cv::solveLP(A, B, z_8u));
|
|
}
|
|
|
|
// Degenerate problem: the first ratio test is a three-way tie.
|
|
// The optimum is unique: z = (16, 15, 0, 24) / 37, objective 189 / 37.
|
|
TEST(Core_LPSolver, issue_12343)
|
|
{
|
|
Mat A = (cv::Mat_<double>(4, 1) << 3., 3., 3., 4.);
|
|
Mat B = (cv::Mat_<double>(4, 5) << 0., 1., 4., 4., 3.,
|
|
3., 1., 2., 2., 3.,
|
|
4., 4., 0., 1., 4.,
|
|
4., 0., 4., 1., 4.);
|
|
Mat z;
|
|
ASSERT_EQ(SOLVELP_SINGLE, cv::solveLP(A, B, z));
|
|
Mat etalon_z = cv::Mat_<double>({4, 1}, {16. / 37, 15. / 37, 0., 24. / 37});
|
|
ASSERT_LT(cvtest::norm(z, etalon_z, cv::NORM_L1), 1e-12);
|
|
}
|
|
|
|
// Cormen's example #1 from regression_basic with the right-hand side scaled by 1e-14.
|
|
// The solution scales with the data: nothing may be treated as zero because it is small.
|
|
TEST(Core_LPSolver, small_magnitude_data)
|
|
{
|
|
const double scale = 1e-14;
|
|
Mat A = cv::Mat_<double>({3, 1}, {3, 1, 2});
|
|
Mat B = cv::Mat_<double>({3, 4}, {1, 1, 3, 30 * scale,
|
|
2, 2, 5, 24 * scale,
|
|
4, 1, 2, 36 * scale});
|
|
Mat z;
|
|
ASSERT_EQ(SOLVELP_SINGLE, cv::solveLP(A, B, z));
|
|
Mat etalon_z = cv::Mat_<double>({3, 1}, {8 * scale, 4 * scale, 0});
|
|
ASSERT_LT(cvtest::norm(z, etalon_z, cv::NORM_L1), 1e-12 * scale);
|
|
}
|
|
|
|
// A negative right-hand side makes solveLP start with Phase I. The objective is parallel to
|
|
// the first constraint, so the optimal points are z = (t, 3 - 3t) for 0 <= t <= 0.9.
|
|
TEST(Core_LPSolver, negative_rhs_restore_cancellation)
|
|
{
|
|
Mat A = cv::Mat_<double>({2, 1}, {-3., -1.});
|
|
Mat B = cv::Mat_<double>({3, 3}, {
|
|
-3., -1., -3.,
|
|
-2., -4., -3.,
|
|
1., 2., 6.
|
|
});
|
|
Mat z;
|
|
ASSERT_EQ(SOLVELP_MULTI, cv::solveLP(A, B, z));
|
|
ASSERT_EQ(2, z.rows);
|
|
const double t = z.at<double>(0);
|
|
EXPECT_GE(t, -1e-12);
|
|
EXPECT_LE(t, 0.9 + 1e-12);
|
|
EXPECT_NEAR(3 - 3 * t, z.at<double>(1), 1e-12);
|
|
}
|
|
|
|
// x1 must be 0 and x2 >= 2/3, so the optimum is unique: z = (0, 2/3), objective -8/3.
|
|
// Phase I ends with its auxiliary variable basic at 0 and a 0 in the first column of its row.
|
|
TEST(Core_LPSolver, phase1_auxiliary_basic_at_zero)
|
|
{
|
|
Mat A = cv::Mat_<double>({2, 1}, {1., -4.});
|
|
Mat B = cv::Mat_<double>({2, 3}, {
|
|
-4., -3., -2.,
|
|
2., 0., 0.
|
|
});
|
|
Mat z;
|
|
ASSERT_EQ(SOLVELP_SINGLE, cv::solveLP(A, B, z));
|
|
Mat etalon_z = cv::Mat_<double>({2, 1}, {0., 2. / 3});
|
|
ASSERT_LT(cvtest::norm(z, etalon_z, cv::NORM_L1), 1e-12);
|
|
}
|
|
|
|
}} // namespace
|