void Mat::Filter(const Mat& filter, Mat &filtered, bool type) const {
if (!type) { // valid filtration
filtered.resize(mat_.size1()+1-filter.size1(), mat_.size2()+1-filter.size2());
for (size_t i = 0; i < filtered.size1(); ++i) {
for (size_t j = 0; j < filtered.size2(); ++j) {
filtered(i, j) = 0;
for (size_t u = 0; u < filter.size1(); ++u) {
for (size_t v = 0; v < filter.size2(); ++v) {
filtered(i, j) += filter(u, v) * mat_(i+u, j+v);
}
}
}
}
} else { // full filtration
filtered.resize(mat_.size1()+filter.size1()-1, mat_.size2()+filter.size2()-1);
for (long i = 0; i < filtered.size1(); ++i) {
for (long j = 0; j < filtered.size2(); ++j) {
filtered(i, j) = 0;
size_t minu = std::max((long) 0, (long) filter.size1() - i - 1);
size_t minv = std::max((long) 0, (long) filter.size2() - j - 1);
size_t maxu = std::min((long) filter.size1(), (long) filtered.size1() - i);
size_t maxv = std::min((long) filter.size2(), (long) filtered.size2() - j);
for (size_t u = minu; u < maxu; ++u) {
for (size_t v = minv; v < maxv; ++v) {
filtered(i, j) += filter(u, v) *
mat_(i+u+1-filter.size1(), j+v+1-filter.size2());
}
}
}
}
}
}
void Mat::SubMat(const std::vector<size_t> ind, size_t dim, Mat &submat) const {
mexAssert(ind.size() > 0, "In SubMat the index vector is empty");
size_t minind = *(std::min_element(ind.begin(), ind.end()));
mexAssert(minind >= 0, "In SubMat one of the indices is less than zero");
if (dim == 1) {
size_t maxind = *(std::max_element(ind.begin(), ind.end()));
mexAssert(maxind < mat_.size1(), "In SubMat one of the indices is larger than the array size");
submat.resize(ind.size(), mat_.size2());
for (size_t i = 0; i < ind.size(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
submat(i, j) = mat_(ind[i], j);
}
}
} else if (dim == 2) {
size_t maxind = *(std::max_element(ind.begin(), ind.end()));
mexAssert(maxind < mat_.size2(), "In SubMat one of the indices is larger than the array size");
submat.resize(mat_.size1(), ind.size());
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < ind.size(); ++j) {
submat(i, j) = mat_(i, ind[j]);
}
}
} else {
mexAssert(false, "In Mat::SubMat the second parameter must be either 1 or 2");
}
}
void Mat::MaxTrim(Mat &trimmed, std::vector<size_t> &coords) const {
mexAssert(trimmed.size1() <= mat_.size1(), "In 'Mat::Trim' the trimmed image is larger than original");
mexAssert(trimmed.size2() <= mat_.size2(), "In 'Mat::Trim' the trimmed image is larger than original");
size_t lv = std::floor((double) (trimmed.size1() - 1)/2);
size_t lh = std::floor((double) (trimmed.size2() - 1)/2);
double maxval = mat_(lv, lh);
coords[0] = lv;
coords[1] = lh;
for (size_t i = lv; i < lv + mat_.size1() - trimmed.size1(); ++i) {
for (size_t j = lh; j < lh + mat_.size2() - trimmed.size2(); ++j) {
if (maxval < mat_(i, j)) {
maxval = mat_(i, j);
coords[0] = i;
coords[1] = j;
}
}
}
for (size_t i = 0; i < trimmed.size1(); ++i) {
for (size_t j = 0; j < trimmed.size2(); ++j) {
trimmed(i, j) = mat_(coords[0]+i-lv, coords[1]+j-lh);
}
}
}
Mat& Mat::AddVect(const Mat &vect, size_t dim) {
if (dim == 1) {
mexAssert(vect.size2() == 1, "In 'Mat::AddVect' the second dimension must be 1");
mexAssert(mat_.size1() == vect.size1(),
"In 'Mat::AddVect' the second dimension of matrix and length of vector are of the different size");
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
mat_(i, j) += vect(i, 0);
}
}
} else if (dim == 2) {
mexAssert(vect.size1() == 1, "In 'Mat::AddVect' the first dimension must be 1");
mexAssert(mat_.size2() == vect.size2(),
"In 'Mat::AddVect' the first dimension of matrix and length of vector are of the different size");
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
mat_(i, j) += vect(0, j);
}
}
} else {
mexAssert(false, "In Mat::AddVect the dimension parameter must be either 1 or 2");
}
return *this;
}
std::vector<size_t> Mat::MaxInd(size_t dim) const {
std::vector<size_t> arrmax;
if (dim == 1) {
arrmax.assign(mat_.size2(), 0);
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
if (mat_(i, j) > mat_(arrmax[j], j)) {
arrmax[j] = i;
}
}
}
} else if (dim == 2) {
arrmax.assign(mat_.size1(), 0);
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
if (mat_(i, j) > mat_(i, arrmax[i])) {
arrmax[i] = j;
}
}
}
} else {
mexAssert(false, "In Mat::MaxInd the dimension parameter must be either 1 or 2");
}
return arrmax;
}
Mat& Mat::Sigmoid() {
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
mat_(i, j) = 1 / (1 + exp(-mat_(i, j)));
}
}
return *this;
}
Mat& Mat::ElemMax(double a) {
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
if (mat_(i, j) < a) mat_(i, j) = a;
}
}
return *this;
}
const double& Mat::operator () (size_t ind) const {
if (mat_.size1() == 1) {
return mat_(0, ind);
} else if (mat_.size2() == 1) {
return mat_(ind, 0);
} else {
mexAssert(false, "In 'Mat::(ind)' matrix is not really a vector");
}
}
Mat& Mat::Sign() {
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
if (mat_(i, j) > 0) {
mat_(i, j) = 1;
} else if (mat_(i, j) < 0) {
mat_(i, j) = -1;
} else {
mat_(i, j) = 0;
}
}
}
return *this;
}
Mat& Mat::ReshapeFrom(const std::vector< std::vector<Mat> > &squeezed) {
// stretches 1, 3 and 4 dimensions size_to the 1st one. The 2nd dimension stays the same.
size_t outputmaps = squeezed.size();
mexAssert(outputmaps > 0, "In 'Mat::ReshapeFrom' the number of output maps is zero");
size_t batchsize = squeezed[0].size();
mexAssert(batchsize > 0, "In 'Mat::ReshapeFrom' the number of batches is zero");
size_t mapsize[2];
mapsize[0] = squeezed[0][0].size1();
mapsize[1] = squeezed[0][0].size2();
size_t numel = mapsize[0] * mapsize[1];
mat_.resize(outputmaps * numel, batchsize);
for (size_t j = 0; j < outputmaps; ++j) {
for (size_t k = 0; k < batchsize; ++k) {
mexAssert(squeezed[j][k].size1() == mapsize[0], "In 'Mat::ReshapeFrom' the first dimension is not constant");
mexAssert(squeezed[j][k].size2() == mapsize[1], "In 'Mat::ReshapeFrom' the second dimension is not constant");
for (size_t u = 0; u < mapsize[0]; ++u) {
for (size_t v = 0; v < mapsize[1]; ++v) {
size_t ind = j*numel + u*mapsize[1] + v;
mat_(ind, k) = squeezed[j][k](u, v);
}
}
}
}
return *this;
}
Mat& Mat::operator += (double a) {
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
mat_(i, j) += a;
}
}
return *this;
}
void Mat::MaxScale(const std::vector<size_t> &scale, Mat &scaled) const {
for (size_t i = 0; i < scaled.size1(); ++i) {
for (size_t j = 0; j < scaled.size2(); ++j) {
size_t maxu = std::min(scale[0], mat_.size1()-i*scale[0]);
size_t maxv = std::min(scale[1], mat_.size2()-j*scale[1]);
scaled(i, j) = mat_(i*scale[0], j*scale[1]);
for (size_t u = 0; u < maxu; ++u) {
for (size_t v = 0; v < maxv; ++v) {
if (scaled(i, j) < mat_(i*scale[0]+u, j*scale[1]+v)) {
scaled(i, j) = mat_(i*scale[0]+u, j*scale[1]+v);
}
}
}
}
}
}
Mat& Mat::CondProd(const Mat &condmat, double threshold, bool incase, double a) {
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
if (incase == (condmat(i, j) > threshold)) mat_(i, j) *= a; // xor
}
}
return *this;
}
Mat& Mat::Rand() {
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
mat_(i, j) = (double) rand() / RAND_MAX;
}
}
return *this;
}
Mat& Mat::assign(double val) {
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
mat_(i, j) = val;
}
}
return *this;
}
double Mat::Sum() const {
double matsum = 0;
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
matsum += mat_(i, j);
}
}
return matsum;
}
std::vector<double> Mat::ToVect() const {
std::vector<double> vect(mat_.size1() * mat_.size2());
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
vect[i*mat_.size2()+j] = mat_(i, j);
}
}
return vect;
}
Mat& Mat::SigmDer(const Mat& a) {
mexAssert(mat_.size1() == a.size1() && mat_.size2() == a.size2(),
"In 'Mat::SigmDer' the matrices are of the different size");
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
mat_(i, j) *= a(i, j) * (1 - a(i, j));
}
}
return *this;
}
void Mat::Sum(size_t dim, Mat &vect) const {
if (dim == 1) {
vect.init(1, mat_.size2(), 0);
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
vect(0, j) += mat_(i, j);
}
}
} else if (dim == 2) {
vect.init(mat_.size1(), 1, 0);
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
vect(i, 0) += mat_(i, j);
}
}
} else {
mexAssert(false, "In Mat::Sum the dimension parameter must be either 1 or 2");
}
}
Mat& Mat::FromVect(const std::vector<double> &vect, const std::vector<size_t> &newsize) {
mexAssert(vect.size() == newsize[0] * newsize[1],
"In 'Mat::FromVect' the vector and sizes do not correspond");
mat_.resize(newsize[0], newsize[1]);
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
mat_(i, j) = vect[i*mat_.size2()+j];
}
}
return *this;
}
Mat& Mat::MultVect(const std::vector<double> &vect, size_t dim) {
if (dim == 1) {
mexAssert(mat_.size1() == vect.size(),
"In 'Mat::MultVect' the second dimension of matrix and length of vector are of the different size");
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
mat_(i, j) *= vect[i];
}
}
} else if (dim == 2) {
mexAssert(mat_.size2() == vect.size(),
"In 'Mat::MultVect' the first dimension of matrix and length of vector are of the different size");
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
mat_(i, j) *= vect[j];
}
}
} else {
mexAssert(false, "In Mat::MultVect the dimension parameter must be either 1 or 2");
}
return *this;
}
void Mat::MeanScaleDer(const std::vector<size_t> &scale, Mat &scaled) const {
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
size_t maxu = std::min(scale[0], scaled.size1()-i*scale[0]);
size_t maxv = std::min(scale[1], scaled.size2()-j*scale[1]);
double scaled_val = mat_(i, j) / (maxu * maxv);
for (size_t u = 0; u < maxu; ++u) {
for (size_t v = 0; v < maxv; ++v) {
scaled(i*scale[0]+u, j*scale[1]+v) = scaled_val;
}
}
}
}
}
void Mat::MaxScaleDer(const std::vector<size_t> &scale, const Mat &val, const Mat &prev_val, Mat &scaled) const {
for (size_t i = 0; i < mat_.size1(); ++i) {
for (size_t j = 0; j < mat_.size2(); ++j) {
size_t maxu = std::min(scale[0], scaled.size1()-i*scale[0]);
size_t maxv = std::min(scale[1], scaled.size2()-j*scale[1]);
for (size_t u = 0; u < maxu; ++u) {
for (size_t v = 0; v < maxv; ++v) {
if (prev_val(i*scale[0]+u, j*scale[1]+v) == val(i, j)) {
scaled(i*scale[0]+u, j*scale[1]+v) = mat_(i, j);
} else {
scaled(i*scale[0]+u, j*scale[1]+v) = 0;
}
}
}
}
}
}
void Mat::MaxRestore(Mat &restored, const std::vector<size_t> &coords) const {
mexAssert(restored.size1() >= mat_.size1(), "In 'Mat::MaxRestore' the restored image is smaller than original");
mexAssert(restored.size2() >= mat_.size2(), "In 'Mat::MaxRestore' the restored image is smaller than original");
size_t lv = std::floor((double) (mat_.size1() - 1)/2);
size_t lh = std::floor((double) (mat_.size2() - 1)/2);
for (size_t i = 0; i < restored.size1(); ++i) {
for (size_t j = 0; j < restored.size2(); ++j) {
if (coords[0] <= i + lv && i + lv < coords[0] + mat_.size1() &&
coords[1] <= j + lh && j + lh < coords[1] + mat_.size2()) {
restored(i, j) = mat_(i+lv-coords[0], j+lh-coords[1]);
} else {
restored(i, j) = 0;
}
}
}
}
void Mat::ReshapeTo(std::vector< std::vector<Mat> > &squeezed,
size_t outputmaps, size_t batchsize,
const std::vector<size_t> &mapsize) const {
size_t numel = mapsize[0] * mapsize[1];
mexAssert(outputmaps * numel == mat_.size1(), "In 'Mat::ReshapeTo' the first dimension do not correspond the parameters");
mexAssert(batchsize == mat_.size2(), "In 'Mat::ReshapeTo' the second dimension do not correspond the parameters");
squeezed.resize(outputmaps);
for (size_t j = 0; j < outputmaps; ++j) {
squeezed[j].resize(batchsize);
for (size_t k = 0; k < batchsize; ++k) {
squeezed[j][k].resize(mapsize);
for (size_t u = 0; u < mapsize[0]; ++u) {
for (size_t v = 0; v < mapsize[1]; ++v) {
size_t ind = j*numel + u*mapsize[1] + v;
squeezed[j][k](u, v) = mat_(ind, k);
}
}
}
}
}
const double& Mat::operator() (size_t ind1, size_t ind2) const {
return mat_(ind1, ind2);
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecForward)
{ /*lint --e{715}*/
SCIP_PROBDATA* probdata;
int n;
int p;
int ndep;
/* "_" means the matrix for blas */
SCIP_Real* y; /* [n] */
SCIP_Real* orig_X_; /* [n*p] */
SCIP_Real* orig_Q_; /* [p*p] <- (X^t) X */
SCIP_Real* orig_q; /* [p] <- (X^t) y */
SCIP_Real r;
int* Mdep; /* [ndep] */
int* groupX; /* [ndep*p] */
/* for forward selection */
int dim;
int* list; /* [p] */
SCIP_Real* a; /* [dim] */
SCIP_Real* a_old; /* [dim-1] */
SCIP_Real* a_new; /* [dim] */
SCIP_Real RSS; /* residual sum of square */
SCIP_Real RSS_new;
SCIP_Real AIC;
SCIP_Real AIC_new;
int ublb;
int *Branchz; /* [3*p] */
/*
* X: sub matrix of orig_X_
* Y: (X^t X)^-1
* X_new = (X, x_i);
* Z: (X_new ^t X_new)^-1
* = ( V v
v^t u )
*/
SCIP_Real* Xy; /* sub vector of orig_q */
SCIP_Real* X_;
SCIP_Real* Y_; /* [(dim-1)*(dim-1)] */
SCIP_Real* Z_; /* [dim*dim] */
SCIP_Real* W_; /* [dim*dim] */
SCIP_Real* V_; /* [(dim-1)*(dim-1)] */
SCIP_Real* v; /* [dim-1] */
SCIP_Real u;
SCIP_Real* b; /* [dim-1] */
SCIP_Real* c; /* [dim-1] */
SCIP_Real* d; /* [n] */
/* variables */
SCIP_VAR** var_a; /* [p] continuous variables */
SCIP_VAR** var_z; /* [p] 01 variables */
SCIP_VAR** var_ep; /* [n] continuous variables */
SCIP_VAR* var_rss; /* continuous variable, residual sum of squares */
SCIP_VAR* var_log; /* continuous variable, log(rss) */
/* set solution */
SCIP_Real *ep;
int nsols;
int store;
SCIP_SOL** sols;
SCIP_Real objval;
SCIP_SOL* sol;
SCIP_Real* solvals;
SCIP_Bool success;
int nvars = SCIPgetNVars(scip);
SCIP_VAR** vars;
int i,j,t,ct;
int memo;
assert(heur != NULL);
assert(scip != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(result != NULL);
#if MYPARA_LOG
printf("forward selection!\n");
#endif
/* get heuristic data */
/*
SCIP_HEURDATA* heurdata;
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
assert(lastsolindices != NULL);
*/
/* get values from probdata */
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
n = SCIPprobdataGetNdatas(probdata);
p = SCIPprobdataGetNexvars(probdata);
ndep = SCIPprobdataGetNdep(probdata);
y = SCIPprobdataGety(probdata);
orig_X_ = SCIPprobdataGetX(probdata);
orig_Q_ = SCIPprobdataGetQ(probdata);
orig_q = SCIPprobdataGetq(probdata);
r = SCIPprobdataGetr(probdata);
if( ndep ){
Mdep = SCIPprobdataGetMdep(probdata);
groupX = SCIPprobdataGetgroupX(probdata);
}else{
Mdep = NULL;
groupX = NULL;
}
/* variables */
var_a = SCIPprobdataGetVars_a(probdata);
var_z = SCIPprobdataGetVars_z(probdata);
var_ep = SCIPprobdataGetVars_ep(probdata);
var_rss = SCIPprobdataGetVar_rss(probdata);
var_log = SCIPprobdataGetVar_log(probdata);
/* get branching info */
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &Branchz, 3*p));
GenerateZeroVecInt( 3*p, Branchz);
for(i=0; i<p; ++i){
ublb = SCIPround(scip, SCIPcomputeVarUbLocal(scip, var_z[i])
+ SCIPcomputeVarLbLocal(scip, var_z[i]));
*(Branchz+(ublb*p)+i) = 1;
}
#if MYPARA_LOG
for(i=0; i<3; i++){
for(j=0; j<p; j++){
printf("%d, ", *(Branchz+(i*p)+j));
}
newline();
}
#endif
if( ndep ){
for(i=0; i<ndep; i++){
memo = -1;
for(j=0; j<p; j++){
if( *(groupX+(i*p)+j)==1 ){
if( *(Branchz+j)==1 ) break;
if( *(Branchz+p+j)==1 ) memo=j;
if( j==Mdep[i] ){
if( memo==-1 ){
printf("error in heur_backward.c\n");
stop();
}
*(Branchz+p+memo) = 0;
*(Branchz+memo) = 1;
break;
}
}
}
}
}
#if MYPARA_LOG
printf("linear dependent\n");
if( ndep ){
for(i=0; i<3; i++){
for(j=0; j<p; j++){
printf("%d, ", *(Branchz+(i*p)+j));
}
newline();
}
}
#endif
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &X_, n*p));
SCIP_CALL( SCIPallocBufferArray(scip, &Xy, p));
SCIP_CALL( SCIPallocBufferArray(scip, &d, n));
SCIP_CALL( SCIPallocBufferArray(scip, &list, p));
/* initialize from Branchz */
#if MYPARA_LOG
printf("initialization\n");
#endif
GenerateZeroVecInt( p, list);
dim = 0;
memo = -1;
AIC = 1e+06;
SCIP_CALL( SCIPallocBufferArray(scip, &a_old, dim+1));
for(i=0; i<p; i++){
if( Branchz[i]==1 ){ /* if z_i is fixed to 0 */
list[i] = -1;
}else if( Branchz[p+i]==1 ){ /* if z_i is unfixed */
list[i] = 0;
}else if( Branchz[2*p+i]==1 ){ /* if z_i is fixed 1 */
dim++;
list[i] = dim;
if( dim == 1 ){
a_old[0] = orig_q[i] / mat_( orig_Q_, p, i, i);
RSS = RSSvalue( 1, a_old, &orig_q[i], r);
AIC = AICvalue( n, dim, RSS);
/* update X_ and Xy */
mydcopy_( &orig_X_[n * i], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[i];
/* generate Y ( dim = 1 ) */
SCIP_CALL( SCIPallocBufferArray( scip, &Y_, dim*dim));
Y_[0] = 1 / mat_( orig_Q_, p, i, i);
}else{
/* alloc */
SCIPfreeBufferArray(scip, &a_old);
SCIP_CALL( SCIPallocBufferArray( scip, &a_old, dim));
SCIP_CALL( SCIPallocBufferArray( scip, &b, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &c, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &v, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &V_, (dim-1)*(dim-1)));
SCIP_CALL( SCIPallocBufferArray( scip, &Z_, (dim)*(dim)));
/* 1. b <- X^t x_i */
dgemv_t( X_, n, dim-1, &orig_X_[n * i], b);
//printv( dim-1, b);
/* 2. c <- Y b */
dgemv_2( Y_, dim-1, dim-1, b, c);
//printv( dim-1, c);
/* 3. d <- - X c + x_i */
dgemv_1( X_, n, dim-1, c, &orig_X_[n * i], -1.0, 1.0, d);
//printv( n, d);
/* 4. u <- 1/<x_i, d> */
u = 1.0 / myddot_( &orig_X_[n * i], d, n);
//prints(u);
/* 5. v <- - u c */
mydscal_( c, dim-1, -u, v);
//printv( dim-1, v);
/* 6. V <- Y + u c c^t */
dger_1( Y_, c, c, dim-1, dim-1, u, V_);
//printM_( V_, dim-1, dim-1);
/* 7. Z */
/* V */
for(j=0; j<(dim-1); j++){
for(t=0; t<(dim-1); t++){
*(Z_ + j + (t*dim) ) = mat_( V_, dim-1, j, t);
}
}
/* v */
for(j=0; j<(dim-1); j++){
*(Z_ + dim-1 + (j*dim) ) = v[j];
*(Z_ + j + ((dim-1)*dim)) = v[j];
}
/* u */
*(Z_ + dim-1 + ((dim-1)*dim)) = u;
//printM_( Z_, dim, dim);
/* 8. a_old <- Z (Xy) */
Xy[dim-1] = orig_q[i];
dgemv_2( Z_, dim, dim, Xy, a_old);
//printv( dim, a_old);
RSS = RSSvalue( dim, a_old, Xy, r);
AIC = AICvalue( n, dim, RSS);
/* copy */
SCIPfreeBufferArray(scip, &Y_);
SCIP_CALL( SCIPallocBufferArray(scip, &Y_, dim*dim));
mydcopy_( Z_, Y_, dim*dim);
/* update X_ and Xy */
mydcopy_( &orig_X_[n * i], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[i];
/* free */
SCIPfreeBufferArray(scip, &b);
SCIPfreeBufferArray(scip, &c);
SCIPfreeBufferArray(scip, &v);
SCIPfreeBufferArray(scip, &V_);
SCIPfreeBufferArray(scip, &Z_);
}
#if MYPARA_LOG
printf("---> %dth variable, AIC:%f\n", i, AIC);
#endif
}else{
printf("error:heur_forward.c\n");
stop();
}
}
if( dim == 0 ){
#if MYPARA_LOG
printf("[dim:0]\n");
#endif
dim++;
RSS = 1e+06;
for(i=0; i<p; i++){
if( list[i] == 0 ){
a_old[0] = orig_q[i] / mat_( orig_Q_, p, i, i);
RSS_new = RSSvalue( 1, a_old, &orig_q[i], r);
if( RSS_new < RSS ){
RSS = RSS_new;
memo = i;
}
#if MYPARA_LOG
printf("%d: RSS = %f\n", i, RSS_new);
#endif
}
}
if( memo < 0 || memo >= p ){
printf("error in heur_forward.c\n");
stop();
}
AIC = AICvalue( n, dim, RSS);
list[memo] = dim;
/* update X_ and Xy */
mydcopy_( &orig_X_[n * memo], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[memo];
/* generate Y ( dim = 1 ) */
SCIP_CALL( SCIPallocBufferArray( scip, &Y_, dim*dim));
Y_[0] = 1 / mat_( orig_Q_, p, memo, memo);
#if MYPARA_LOG
printf("---> %dth variable, AIC:%f\n", memo, AIC);
#endif
} /* if ( dim==0 ) */
while(1){
dim++;
memo = -1;
RSS = 1e+06;
#if MYPARA_LOG
printf("(dim=%d) ", dim);
Longline();
#endif
/* alloc */
SCIP_CALL( SCIPallocBufferArray( scip, &a_new, dim));
SCIP_CALL( SCIPallocBufferArray( scip, &a, dim));
SCIP_CALL( SCIPallocBufferArray( scip, &b, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &c, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &v, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &V_, (dim-1)*(dim-1)));
SCIP_CALL( SCIPallocBufferArray( scip, &Z_, (dim)*(dim)));
SCIP_CALL( SCIPallocBufferArray( scip, &W_, (dim)*(dim)));
for(i=0; i<p; i++){
/*
* 1. b <- X^t x_i
* 2. c <- Y b
* 3. d <- - X c + x_i
* 4. u <- 1 / <x_i, d>
* 5. v <- - u c
* 6. V <- Y + u c c^t
* 7. Z <- ( V v
v^t u )
* 8. a_new <- Z (Xy)
*/
if( list[i]==0 ){
/* 1. b <- X^t x_i */
dgemv_t( X_, n, dim-1, &orig_X_[n * i], b);
//printv( dim-1, b);
/* 2. c <- Y b */
dgemv_2( Y_, dim-1, dim-1, b, c);
//printv( dim-1, c);
/* 3. d <- - X c + x_i */
dgemv_1( X_, n, dim-1, c, &orig_X_[n * i], -1.0, 1.0, d);
//printv( n, d);
/* 4. u <- 1/<x_i, d> */
u = 1.0 / myddot_( &orig_X_[n * i], d, n);
//prints(u);
/* 5. v <- - u c */
mydscal_( c, dim-1, -u, v);
//printv( dim-1, v);
/* 6. V <- Y + u c c^t */
dger_1( Y_, c, c, dim-1, dim-1, u, V_);
//printM_( V_, dim-1, dim-1);
/* 7. Z */
/* V */
for(j=0; j<(dim-1); j++){
for(t=0; t<(dim-1); t++){
*(Z_ + j + (t*dim) ) = mat_( V_, dim-1, j, t);
}
}
/* v */
for(j=0; j<(dim-1); j++){
*(Z_ + dim-1 + (j*dim) ) = v[j];
*(Z_ + j + ((dim-1)*dim)) = v[j];
}
/* u */
*(Z_ + dim-1 + ((dim-1)*dim)) = u;
//printM_( Z_, dim, dim);
/* 8. a_new <- Z (Xy) */
Xy[dim-1] = orig_q[i];
dgemv_2( Z_, dim, dim, Xy, a_new);
//printv( dim, a_new);
/* test */
RSS_new = RSSvalue( dim, a_new, Xy, r);
if( RSS_new < RSS ){
RSS = RSS_new;
memo = i;
mydcopy_( Z_, W_, dim*dim);
mydcopy_( a_new, a, dim);
}
#if MYPARA_LOG
printf("%d: RSS = %f\n", i, RSS_new);
#endif
}
}
if( memo < 0 || memo >= p ){
if( memo == -1 ){
for(i=0; i<p; i++){
if( list[i] == 0 ){
memo = i;
break;
}
}
if( memo != -1 ){
printf("error in heur_forward.c\n");
stop();
}
}else{
printf("error in heur_forward.c\n");
stop();
}
}
AIC_new = AICvalue( n, dim, RSS);
if( AIC_new < AIC ){
AIC = AIC_new;
list[memo] = dim;
#if MYPARA_LOG
printf("---> %dth variable, AIC:%f\n", memo, AIC);
#endif
/* copy and free */
SCIPfreeBufferArray(scip, &Y_);
SCIP_CALL( SCIPallocBufferArray(scip, &Y_, dim*dim));
mydcopy_( W_, Y_, dim*dim);
SCIPfreeBufferArray(scip, &a_old);
SCIP_CALL( SCIPallocBufferArray(scip, &a_old, dim));
mydcopy_( a, a_old, dim);
/* update X_ and Xy */
mydcopy_( &orig_X_[n * memo], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[memo];
}else{
memo = -1;
SCIPfreeBufferArray(scip, Y_);
#if MYPARA_LOG
printf("--> no selection, (AIC:%f)\n", AIC_new);
#endif
}
/* free */
SCIPfreeBufferArray(scip, &a_new);
SCIPfreeBufferArray(scip, &a);
SCIPfreeBufferArray(scip, &b);
SCIPfreeBufferArray(scip, &c);
SCIPfreeBufferArray(scip, &v);
SCIPfreeBufferArray(scip, &V_);
SCIPfreeBufferArray(scip, &Z_);
SCIPfreeBufferArray(scip, &W_);
if( memo == -1 ){
dim--;
break;
}
}
nsols = SCIPgetNSols(scip);
if( nsols < MP_NUM_SOL ){
store = 1;
}else{
sols = SCIPgetSols(scip);
objval = AIC;
nsols = MP_NUM_SOL;
if( objval < SCIPgetSolOrigObj(scip,sols[nsols-1]) ){
store = 1;
}else{
store = 0;
}
}
if( store ){
/* generate solution */
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &ep, n));
dgemv_1( X_, n, dim, a_old, y, -1.0, 1.0, ep);
/* set solution */
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &solvals, nvars));
SCIP_CALL( SCIPallocBufferArray(scip, &vars, nvars));
ct=0;
/* a */
for(i=0; i<p; ++i){
vars[ct] = var_a[i];
if( list[i] > 0 ){
solvals[ct] = a_old[list[i]-1];
}else{
solvals[ct] = 0.0;
}
ct++;
}
/* z */
for(i=0; i<p; i++){
vars[ct] = var_z[i];
if( list[i] > 0 ){
solvals[ct] = 1.0;
}else{
solvals[ct] = 0.0;
}
ct++;
}
/* ep */
for(i=0; i<n; ++i){
vars[ct] = var_ep[i];
solvals[ct] = ep[i];
ct++;
}
vars[ct] = var_rss;
solvals[ct] = myddot_( ep, ep, n);
ct++;
vars[ct] = var_log;
solvals[ct] = log(myddot_( ep, ep, n));
ct++;
if( ct!=nvars ){
SCIPerrorMessage("It is unexpected error in set sol,");
printf("( ct, nvars) = ( %d, %d)", ct, nvars);
stop();
}
SCIP_CALL( SCIPcreateSol(scip, &sol, heur));
SCIP_CALL( SCIPsetSolVals(scip, sol, nvars, vars, solvals));
SCIP_CALL( SCIPtrySolFree(scip, &sol, TRUE, FALSE, TRUE, TRUE, &success));
/* free */
SCIPfreeBufferArray(scip, &ep);
SCIPfreeBufferArray(scip, &solvals);
SCIPfreeBufferArray(scip, &vars);
}
/* free */
SCIPfreeBufferArray(scip, &d);
SCIPfreeBufferArray(scip, &X_);
SCIPfreeBufferArray(scip, &Xy);
SCIPfreeBufferArray(scip, &a_old);
SCIPfreeBufferArray(scip, &list);
SCIPfreeBufferArray(scip, &Branchz);
*result = SCIP_FOUNDSOL;
return SCIP_OKAY;
}
void Pose::UpdateMat() {
Matx33d rmat;
Rodrigues(rvec_, rmat);
mat_(0, 0) = rmat(0, 0);
mat_(0, 1) = rmat(0, 1);
mat_(0, 2) = rmat(0, 2);
mat_(1, 0) = rmat(1, 0);
mat_(1, 1) = rmat(1, 1);
mat_(1, 2) = rmat(1, 2);
mat_(2, 0) = rmat(2, 0);
mat_(2, 1) = rmat(2, 1);
mat_(2, 2) = rmat(2, 2);
mat_(0, 3) = tvec_(0);
mat_(1, 3) = tvec_(1);
mat_(2, 3) = tvec_(2);
}
static
SCIP_DECL_BRANCHEXECPS(branchExecpsMyfullstrong)
{ /*lint --e{715}*/
SCIP_PROBDATA* probdata;
SCIP_VAR** cands;
int ncands;
SCIP_NODE* childnode_0; /* z_j = 0 */
SCIP_NODE* childnode_1; /* z_j = 1 */
/* probdata */
int p;
int ndep;
SCIP_VAR** var_z; /* [p] 01 variables */
/* "_" means the matrix for blas */
SCIP_Real* orig_Q_; /* [p*p] <- (X^t) X */
SCIP_Real* orig_q; /* [p] <- (X^t) y */
SCIP_Real r;
int* Mdep; /* [ndep] */
int* groupX; /* [ndep*p] */
int dim;
SCIP_Real RSS; /* residual sum of square */
SCIP_Real RSS_new;
SCIP_Real* a; /* [dim] */
int ublb;
int *Branchz; /* [3*p] */
int *Branchz_new; /* [3*p] */
SCIP_Real* Q_; /* sub matrix of orig_Q_ */
SCIP_Real* Xy; /* sub vector of orig_q */
int* list; /* list of candidate variables */
int i,j,t,memo,ct;
int ind;
int dpv;
#if MYPARA_LOG
printf("[myfullstrong brnaching]");
Longline();
#endif
/* get branching rule data */
/*
SCIP_BRANCHRULEDATA* branchruledata;
branchruledata = SCIPbranchruleGetData(branchrule);
assert(branchruledata != NULL);
*/
/* get problem data*/
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
p = SCIPprobdataGetNexvars(probdata);
ndep = SCIPprobdataGetNdep(probdata);
orig_Q_ = SCIPprobdataGetQ(probdata);
orig_q = SCIPprobdataGetq(probdata);
r = SCIPprobdataGetr(probdata);
var_z = SCIPprobdataGetVars_z(probdata);
if( ndep ){
Mdep = SCIPprobdataGetMdep(probdata);
groupX = SCIPprobdataGetgroupX(probdata);
}else{
Mdep = NULL;
groupX = NULL;
}
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &list, p));
SCIP_CALL( SCIPallocBufferArray(scip, &Branchz, 3*p));
SCIP_CALL( SCIPallocBufferArray(scip, &Branchz_new, 3*p));
GenerateZeroVecInt( p, list);
GenerateZeroVecInt( 3*p, Branchz);
/* get pseudo candidates (non-fixed integer variables) */
SCIP_CALL( SCIPgetPseudoBranchCands(scip, &cands, NULL, &ncands) );
for(i=0; i<ncands; i++){
for(j=0; j<p; j++){
if( cands[i]==var_z[j] ){
list[j] = 1;
break;
}
}
}
#if MYPARA_LOG
printf("list:");
printintv( p, list);
#endif
/* get branching info */
for(i=0; i<p; ++i){
ublb = SCIPround(scip, SCIPcomputeVarUbLocal(scip, var_z[i])
+ SCIPcomputeVarLbLocal(scip, var_z[i]));
*(Branchz+(ublb*p)+i) = 1;
}
#if MYPARA_LOG
for(i=0; i<3; i++){
for(j=0; j<p; j++){
printf("%d, ", *(Branchz+(i*p)+j));
}
newline();
}
#endif
RSS = -1.0;
ind = -1;
for(i=0; i<p; i++){
/* copy */
for(j=0; j<(3*p); j++){
Branchz_new[j] = Branchz[j];
}
/*
* solve
* Q a = Xy
*/
if( list[i] == 1 ){
Branchz_new[i] = 1;
Branchz_new[p+i] = 0;
if( ndep ){
for(t=0; t<ndep; t++){
memo = -1;
for(j=0; j<p; j++){
if( *(groupX+(t*p)+j)==1 ){
if( Branchz_new[j]==1 ) break;
if( Branchz_new[p+j]==1 ) memo=j;
if( j==Mdep[t] ){
if( memo==-1 ){
printf("error in branch_myfullstrong.c\n");
stop();
}
*(Branchz_new+p+memo) = 0;
*(Branchz_new+memo) = 1;
break;
}
}
}
}
}
dim = p - sumint( &Branchz_new[0], p);
/* alloc */
SCIP_CALL( SCIPallocBufferArray( scip, &a, dim));
SCIP_CALL( SCIPallocBufferArray( scip, &Q_, dim*dim));
SCIP_CALL( SCIPallocBufferArray( scip, &Xy, dim));
/* generate Q and Xy */
/* Q */
ct = 0;
for(j=0; j<p; j++){
if( (Branchz_new[j]==0) && (j != i) ){
for(t=0; t<p; t++){
if( (Branchz_new[t]==0) && (t != i ) ){
Q_[ct++] = mat_( orig_Q_, p, j, t);
}
}
}
}
if( ct != (dim*dim) ){
printf("error in branch_myfullstrong.c\n");
stop();
}
/* Xy */
ct = 0;
for(j=0; j<p; j++){
if( (Branchz_new[j]==0) && (j != i) ){
Xy[ct++] = orig_q[j];
}
}
if( ct != dim ){
printf("error in branch_myfullstrong.c\n");
stop();
}
dpv = _dposv_( Q_, Xy, dim, a);
if( dpv == 0 ){
/* test */
RSS_new = RSSvalue( dim, a, Xy, r);
if( RSS_new > RSS ){
RSS = RSS_new;
ind = i;
}
#if MYPARA_LOG
printf("%d: RSS = %f\n", i, RSS_new);
#endif
}
/* free */
SCIPfreeBufferArray(scip, &Q_);
SCIPfreeBufferArray(scip, &Xy);
SCIPfreeBufferArray(scip, &a);
}
}
#if MYPARA_LOG
printf("max->%dth var. \n", ind);
#endif
if( ind == -1 ){
/* free */
SCIPfreeBufferArray(scip, &list);
SCIPfreeBufferArray(scip, &Branchz);
SCIPfreeBufferArray(scip, &Branchz_new);
*result = SCIP_DIDNOTRUN;
return SCIP_OKAY;
}
SCIP_CALL( SCIPbranchVar( scip, var_z[ind], &childnode_0, NULL, &childnode_1));
/* free */
SCIPfreeBufferArray(scip, &list);
SCIPfreeBufferArray(scip, &Branchz);
SCIPfreeBufferArray(scip, &Branchz_new);
*result = SCIP_BRANCHED;
return SCIP_OKAY;
}
