static void range(const point_t *x, size_t c, box_t *B)
{
while (c--)
{
bd(&(B->min.x), x[c].x);
bu(&(B->max.x), x[c].x);
bd(&(B->min.y), x[c].y);
bu(&(B->max.y), x[c].y);
}
}
int main(int argc, char *argv[])
{
// cout << "argc:" << argc <<endl;
QString classes = "ALL";
if (argc!=4)
usage(argv[0]);
BottomUp bu(argv[1]); // read infile tnt.uni-hannover.de/
NodeList *nl = bu.selectClass("ALL");
qDebug("no elem %d",nl->count());
if (nl->isEmpty()) return 0;
Stack stack(nl,argv[2]);
QString command(argv[3]);
qDebug("Command=%s",command.latin1());
stack.registerFunction("neighbour", neighbour);
if (!stack.run(command)){
std::cerr << "ga_bu_generic: Error while running stack" << std::endl;
return EXIT_FAILURE;
}
stack.write(argv[2]);
nl->writeOutImage(QString(argv[2])+".bu.node.plm");
nl->writeGroupImage(QString(argv[2])+".bu.plm");
}
int main() {
while(scanf("%d%d",&n,&m) != EOF) {
solve();
bu();
}
return 0;
}
/*! \brief constructor
*
* \param dom Box domain
* \param n_sub number of sub-domain to create (it is approximated to the biggest 2^n number)
* \param lp Local position of the particles
*
*/
ORB(Box dom, size_t n_sub, loc_pos & lp)
:v_cl(create_vcluster()),lp(lp)
{
typedef ORB<dim,T,loc_wg,loc_pos,Box,Tree> ORB_class;
dim_div = 0;
n_sub = openfpm::math::round_big_2(n_sub);
size_t nsub = log2(n_sub);
// number of center or mass needed
cm.resize(2 << nsub);
cm_cnt.resize(2 << nsub);
// Every time we divide from 0 to dim-1, calculate how many cycle from 0 to dim-1 we have
size_t dim_cycle = nsub / dim;
// Create the root node in the graph
grp.addVertex();
// unroll bisection cycle
bisect_unroll<dim,ORB_class> bu(*this);
for (size_t i = 0 ; i < dim_cycle ; i++)
{
boost::mpl::for_each< boost::mpl::range_c<int,0,dim> >(bu);
// bu is recreated several time internaly
}
// calculate and execute the remaining cycles
switch(nsub - dim_cycle * dim)
{
case 1:
do_when_dim_gr_i<dim,1,ORB_class>::bisect_loop(bu);
break;
case 2:
do_when_dim_gr_i<dim,2,ORB_class>::bisect_loop(bu);
break;
case 3:
do_when_dim_gr_i<dim,3,ORB_class>::bisect_loop(bu);
break;
case 4:
do_when_dim_gr_i<dim,4,ORB_class>::bisect_loop(bu);
break;
case 5:
do_when_dim_gr_i<dim,5,ORB_class>::bisect_loop(bu);
break;
case 6:
do_when_dim_gr_i<dim,6,ORB_class>::bisect_loop(bu);
break;
case 7:
do_when_dim_gr_i<dim,7,ORB_class>::bisect_loop(bu);
break;
default:
// To extend on higher dimension create other cases or create runtime
// version of local_cm and bisect
std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << " ORB is not working for dimension bigger than 8";
}
}
double bright::Reactor1G::batch_average(double BUd, std::string PDk_flag)
{
// Finds the batch-averaged P(F), D(F), or k(F) when at discharge burnup BUd.
std::string PDk = pyne::to_upper(PDk_flag);
// For B batches (indexed from 0 -> B-1) calculate BU of each batch.
std::vector<double> bu (B, 0.0);
for (int b = 0; b < B; b++)
bu[b] = ((double) b + 1) * BUd / ((double) B);
// Calculate Fluence points for each BU
std::vector<FluencePoint> fps;
fps.resize(B);
for (int b = 0; b < B; b++)
fps[b] = fluence_at_BU(bu[b]);
std::vector<double> PDks (B, 0.0);
for (int b = 0; b < B; b++)
{
double p;
double d;
if ( (fps[b].f + 1) == F.size() )
{
p = pyne::solve_line(fps[b].F, F[fps[b].f], P_F_[fps[b].f], F[fps[b].f-1], P_F_[fps[b].f-1]);
d = pyne::solve_line(fps[b].F, F[fps[b].f], D_F_[fps[b].f], F[fps[b].f-1], D_F_[fps[b].f-1]);
}
else
{
p = pyne::solve_line(fps[b].F, F[fps[b].f+1], P_F_[fps[b].f+1], F[fps[b].f], P_F_[fps[b].f]);
d = pyne::solve_line(fps[b].F, F[fps[b].f+1], D_F_[fps[b].f+1], F[fps[b].f], D_F_[fps[b].f]);
};
if (PDk == "K")
PDks[b] = (p/d);
else if (PDk == "P")
PDks[b] = p;
else if (PDk == "D")
PDks[b] = d;
else
{
if (1 < bright::verbosity)
std::cout << "PDk flag is wrong: " << PDk << "\nUsing default of k.\n";
PDks[b] = (p/d);
};
};
double numerator = 0.0;
double denominator = 0.0;
for (int b = 0; b < B; b++)
{
numerator = numerator + (PDks[b] / fps[b].m);
denominator = denominator + (1.0 / fps[b].m);
};
return numerator/denominator;
};
br_status fpa_rewriter::mk_to_sbv_unspecified(unsigned ebits, unsigned sbits, unsigned width, expr_ref & result) {
bv_util bu(m());
if (m_hi_fp_unspecified)
// The "hardware interpretation" is 0.
result = bu.mk_numeral(0, width);
else
result = m_util.mk_internal_to_sbv_unspecified(ebits, sbits, width);
return BR_DONE;
}
void fpa2bv_model_converter::convert(model * bv_mdl, model * float_mdl) {
float_util fu(m);
bv_util bu(m);
mpf fp_val;
unsynch_mpz_manager & mpzm = fu.fm().mpz_manager();
unsynch_mpq_manager & mpqm = fu.fm().mpq_manager();
TRACE("fpa2bv_mc", tout << "BV Model: " << std::endl;
for (unsigned i = 0; i < bv_mdl->get_num_constants(); i++)
tout << bv_mdl->get_constant(i)->get_name() << " --> " <<
mk_ismt2_pp(bv_mdl->get_const_interp(bv_mdl->get_constant(i)), m) << std::endl;
);
br_status fpa_rewriter::mk_to_ieee_bv_unspecified(func_decl * f, expr_ref & result) {
bv_util bu(m());
unsigned bv_sz = bu.get_bv_size(f->get_range());
if (m_hi_fp_unspecified)
// The "hardware interpretation" is 0.
result = bu.mk_numeral(0, bv_sz);
else
result = m_util.mk_internal_to_ieee_bv_unspecified(bv_sz);
return BR_DONE;
}
RestorationProblem::RestorationProblem( Problemspec *parentProblem, const Matrix &xiReference )
{
int i, iVar, iCon;
parent = parentProblem;
xiRef.Dimension( parent->nVar );
for( i=0; i<parent->nVar; i++)
xiRef( i ) = xiReference( i );
/* nCon slack variables */
nVar = parent->nVar + parent->nCon;
nCon = parent->nCon;
/* Block structure: One additional block for every slack variable */
nBlocks = parent->nBlocks+nCon;
blockIdx = new int[nBlocks+1];
for( i=0; i<parent->nBlocks+1; i++ )
blockIdx[i] = parent->blockIdx[i];
for( i=parent->nBlocks+1; i<nBlocks+1; i++ )
blockIdx[i] = blockIdx[i-1]+1;
/* Set bounds */
objLo = 0.0;
objUp = 1.0e20;
bl.Dimension( nVar + nCon ).Initialize( -1.0e20 );
bu.Dimension( nVar + nCon ).Initialize( 1.0e20 );
for( iVar=0; iVar<parent->nVar; iVar++ )
{
bl( iVar ) = parent->bl( iVar );
bu( iVar ) = parent->bu( iVar );
}
for( iCon=0; iCon<parent->nCon; iCon++ )
{
bl( nVar+iCon ) = parent->bl( parent->nVar+iCon );
bu( nVar+iCon ) = parent->bu( parent->nVar+iCon );
}
}
br_status fpa_rewriter::mk_to_ieee_bv_unspecified(func_decl * f, expr_ref & result) {
SASSERT(f->get_num_parameters() == 1);
SASSERT(f->get_parameter(0).is_int());
unsigned bv_sz = f->get_parameter(0).get_int();
bv_util bu(m());
if (m_hi_fp_unspecified)
// The "hardware interpretation" is 0.
result = bu.mk_numeral(0, bv_sz);
else
result = m_util.mk_internal_to_ieee_bv_unspecified(bv_sz);
return BR_DONE;
}
br_status fpa_rewriter::mk_to_fp(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
SASSERT(f->get_num_parameters() == 2);
SASSERT(f->get_parameter(0).is_int());
SASSERT(f->get_parameter(1).is_int());
bv_util bu(m());
scoped_mpf v(m_fm);
mpf_rounding_mode rmv;
rational r1, r2, r3;
unsigned bvs1, bvs2, bvs3;
unsigned ebits = f->get_parameter(0).get_int();
unsigned sbits = f->get_parameter(1).get_int();
if (num_args == 1) {
if (bu.is_numeral(args[0], r1, bvs1)) {
// BV -> float
SASSERT(bvs1 == sbits + ebits);
unsynch_mpz_manager & mpzm = m_fm.mpz_manager();
unsynch_mpq_manager & mpqm = m_fm.mpq_manager();
scoped_mpz sig(mpzm), exp(mpzm);
const mpz & sm1 = m_fm.m_powers2(sbits - 1);
const mpz & em1 = m_fm.m_powers2(ebits);
scoped_mpq q(mpqm);
mpqm.set(q, r1.to_mpq());
SASSERT(mpzm.is_one(q.get().denominator()));
scoped_mpz z(mpzm);
z = q.get().numerator();
mpzm.rem(z, sm1, sig);
mpzm.div(z, sm1, z);
mpzm.rem(z, em1, exp);
mpzm.div(z, em1, z);
SASSERT(mpzm.is_int64(exp));
mpf_exp_t mpf_exp = mpzm.get_int64(exp);
mpf_exp = m_fm.unbias_exp(ebits, mpf_exp);
m_fm.set(v, ebits, sbits, !mpzm.is_zero(z), sig, mpf_exp);
TRACE("fp_rewriter",
tout << "sgn: " << !mpzm.is_zero(z) << std::endl;
tout << "sig: " << mpzm.to_string(sig) << std::endl;
tout << "exp: " << mpf_exp << std::endl;
tout << "v: " << m_fm.to_string(v) << std::endl;);
result = m_util.mk_value(v);
return BR_DONE;
}
inline void load_img( MP img, QImage& qimg)
{
QString src = img[ "img.src" ];
if(QFile::exists(src)) {
qimg.load(src);
}
else {
src.remove(0,22); // Remove MIME type
QByteArray b6;
b6.append(src);
QByteArray ba = QByteArray::fromBase64(b6);
QBuffer bu(&ba);
qimg.load(&bu,"PNG");
}
}
int main(int argc,char** argv){
double prec = 1e-6;
Buca bu(0);
FunzioneBase* t = &(bu);
Bisezione bis(3000);
bis.Precision(prec);
double a, b, zero;
for (int i=0;i<21;++i){
a=i*M_PI;
b=i*M_PI+M_PI/2;
zero = bis.CercaZeri(a,b,&bu);
std::cout << std::fixed << "Zero trovato: " << std::setprecision(-log10(prec)) << zero << " nell'intervallo ["<<a<<","<<b<<"]"<<std::endl;
}
return 0;
}
/**
* \fn void comp_bpoly_matrix( double**& a , double* param_pts , unsigned np ) const
*
* \brief Computes the pairwise product of all Bernstein polynomials
* of two degrees at a given set of parameters points. The two
* degrees are the the first and second index of the bi-degree of
* this patch.
*
* \param a A (np x (( m + 1) * ( n + 1)) matrix such that ( m , n )
* is the bi-degree of this patch and each element of the matrix is
* a product of two Bernstein polynomials at a given parameter
* point.
* \param patch_pts An array of 2D coordinates of parameter points.
* \param np The number of parameter points.
*/
void
tBezier::comp_bpoly_matrix(
double**& a ,
double* param_pts ,
unsigned np
)
const
{
/**
* Compute the value of the Bernstein polynomials at the parameter
* points.
*/
double rx = get_aff_1st_point_x_coord() ;
double ry = get_aff_1st_point_y_coord() ;
double sx = get_aff_2nd_point_x_coord() ;
double sy = get_aff_2nd_point_y_coord() ;
for ( unsigned i = 0 ; i < np ; i++ ) {
double x = ( param_pts[ ( i << 1 ) ] - rx ) /
( sx - rx ) ;
double y = ( param_pts[ ( i << 1 ) + 1 ] - ry ) /
( sy - ry ) ;
unsigned m = get_bidegree_1st_index() ;
unsigned n = get_bidegree_2nd_index() ;
std::vector< double > bu( m + 1 ) ;
std::vector< double > bv( n + 1 ) ;
all_bernstein( m , x , bu ) ;
all_bernstein( n , y , bv ) ;
for ( unsigned k = 0 ; k <= n ; ++k ) {
for ( unsigned j = 0 ; j <= m ; ++j ) {
unsigned l = index( k , j ) ;
a[ i ][ l ] = bu[ j ] * bv[ k ] ;
}
}
}
return ;
}
int main(int argc, char *argv[])
{
//cout << "argc:" << argc <<endl;
QString classes = "ALL";
if (argc < 4) // || argc > 5 )
usage(argv[0]);
if (argc >= 5) classes = argv[4];
unsigned int maxsize = atoi(argv[3]);
BottomUp bu(argv[1]); // read infile
//BottomUp bu("/project/geoaida/share/data/test_files/ga_bu_maxsize/input-27656-0171");
NodeList *nl = bu.selectClass(classes); //select given classes
RegionSensor *rs = new RegionSensor();
for (int n=5; n<argc; n++) {
cout <<argv[n]<<", ";
*nl += (*(bu.selectClass(argv[n])));
}
nl->calcForSelect ("size", rs);
Node *node1;
QDictIterator<Node> it( *nl ); // iterator for nl
QFile fp(argv[2]);
//QFile fp("/project/geoaida/share/data/test_files/ga_bu_maxsize/outfile");
if (!fp.open(IO_WriteOnly)) qDebug("write: file not accesable to %s\n",argv[2]);
QTextStream str(&fp);
str<<"<REGION\n";
while(it.current()) { //run over list
node1=nl->take(it.currentKey()); //it.current();
unsigned int size = ((*node1)["size"])->toUInt();
if (size<=maxsize) node1->write(str);
++it;
it.toFirst();
}
str<<"/>\n";
fp.close();
cout << "FIN .. "<<endl;
#ifdef WIN32
return(0);
#endif
}
main()
{
char s[100000] ;
bool fir=1 ;
while(scanf("%s",s)!=EOF)
{
if(fir) fir=0 ;
else printf("\n") ;
int l=strlen(s) ;
int n=1000*(s[l-4]-'0')+100*(s[l-3]-'0')+10*(s[l-2]-'0')+(s[l-1]-'0') ;
int x=an(n),y=hu(s,l),z=(bu(s,l))&&(an(n)) ;
if((!x) && (!y) && (!z))
printf("This is an ordinary year.\n") ;
else
{
if(x) printf("This is leap year.\n") ;
if(y) printf("This is huluculu festival year.\n") ;
if(z) printf("This is bulukulu festival year.\n") ;
}
}
}
void FLCheckBox::drawButton(QPainter *p)
{
QRect rect, wrect(this->rect());
rect.setRect((wrect.width() - 13) / 2, (wrect.height() - 13) / 2, 13, 13);
if (state() == QButton::On) {
QBrush bu(green, SolidPattern);
p->fillRect(0, 0, wrect.width() - 1, wrect.height() - 1, bu);
}
QRect irect = QStyle::visualRect(rect, this);
p->fillRect(irect, Qt::white);
p->drawRect(irect);
if (state() == QButton::On) {
QPointArray a(7 * 2);
int i, xx, yy;
xx = irect.x() + 3;
yy = irect.y() + 5;
for (i = 0; i < 3; i++) {
a.setPoint(2 * i, xx, yy);
a.setPoint(2 * i + 1, xx, yy + 2);
xx++;
yy++;
}
yy -= 2;
for (i = 3; i < 7; i++) {
a.setPoint(2 * i, xx, yy);
a.setPoint(2 * i + 1, xx, yy + 2);
xx++;
yy--;
}
p->drawLineSegments(a);
}
drawButtonLabel(p);
}
expr_ref fpa2bv_model_converter_prec::convert_bv2fp(sort * s, expr * sgn, expr * exp, expr * sig) const {
fpa_util fu(m);
bv_util bu(m);
unsynch_mpz_manager & mpzm = fu.fm().mpz_manager();
unsynch_mpq_manager & mpqm = fu.fm().mpq_manager();
expr_ref res(m);
mpf fp_val;
unsigned ebits = fu.get_ebits(s);
unsigned sbits = fu.get_sbits(s);
unsigned sgn_sz = 1;
unsigned exp_sz = ebits;
unsigned sig_sz = sbits - 1;
rational sgn_q(0), sig_q(0), exp_q(0);
if (sgn) bu.is_numeral(sgn, sgn_q, sgn_sz);
if (exp) bu.is_numeral(exp, exp_q, exp_sz);
if (sig) bu.is_numeral(sig, sig_q, sig_sz);
// un-bias exponent
rational exp_unbiased_q;
exp_unbiased_q = exp_q - fu.fm().m_powers2.m1(ebits - 1);
mpz sig_z; mpf_exp_t exp_z;
mpzm.set(sig_z, sig_q.to_mpq().numerator());
exp_z = mpzm.get_int64(exp_unbiased_q.to_mpq().numerator());
fu.fm().set(fp_val, ebits, sbits, !mpqm.is_zero(sgn_q.to_mpq()), exp_z, sig_z);
mpzm.del(sig_z);
res = fu.mk_value(fp_val);
TRACE("fpa2bv_mc", tout << "[" << mk_ismt2_pp(sgn, m) <<
" " << mk_ismt2_pp(exp, m) <<
" " << mk_ismt2_pp(sig, m) << "] == " <<
mk_ismt2_pp(res, m) << std::endl;);
// ** Temporary version
int
ClpPdco::pdco( ClpPdcoBase * stuff, Options &options, Info &info, Outfo &outfo)
{
// D1, D2 are positive-definite diagonal matrices defined from d1, d2.
// In particular, d2 indicates the accuracy required for
// satisfying each row of Ax = b.
//
// D1 and D2 (via d1 and d2) provide primal and dual regularization
// respectively. They ensure that the primal and dual solutions
// (x,r) and (y,z) are unique and bounded.
//
// A scalar d1 is equivalent to d1 = ones(n,1), D1 = diag(d1).
// A scalar d2 is equivalent to d2 = ones(m,1), D2 = diag(d2).
// Typically, d1 = d2 = 1e-4.
// These values perturb phi(x) only slightly (by about 1e-8) and request
// that A*x = b be satisfied quite accurately (to about 1e-8).
// Set d1 = 1e-4, d2 = 1 for least-squares problems with bound constraints.
// The problem is then
//
// minimize phi(x) + 1/2 norm(d1*x)^2 + 1/2 norm(A*x - b)^2
// subject to bl <= x <= bu.
//
// More generally, d1 and d2 may be n and m vectors containing any positive
// values (preferably not too small, and typically no larger than 1).
// Bigger elements of d1 and d2 improve the stability of the solver.
//
// At an optimal solution, if x(j) is on its lower or upper bound,
// the corresponding z(j) is positive or negative respectively.
// If x(j) is between its bounds, z(j) = 0.
// If bl(j) = bu(j), x(j) is fixed at that value and z(j) may have
// either sign.
//
// Also, r and y satisfy r = D2 y, so that Ax + D2^2 y = b.
// Thus if d2(i) = 1e-4, the i-th row of Ax = b will be satisfied to
// approximately 1e-8. This determines how large d2(i) can safely be.
//
//
// EXTERNAL FUNCTIONS:
// options = pdcoSet; provided with pdco.m
// [obj,grad,hess] = pdObj( x ); provided by user
// y = pdMat( name,mode,m,n,x ); provided by user if pdMat
// is a string, not a matrix
//
// INPUT ARGUMENTS:
// pdObj is a string containing the name of a function pdObj.m
// or a function_handle for such a function
// such that [obj,grad,hess] = pdObj(x) defines
// obj = phi(x) : a scalar,
// grad = gradient of phi(x) : an n-vector,
// hess = diag(Hessian of phi): an n-vector.
// Examples:
// If phi(x) is the linear function c"x, pdObj should return
// [obj,grad,hess] = [c"*x, c, zeros(n,1)].
// If phi(x) is the entropy function E(x) = sum x(j) log x(j),
// [obj,grad,hess] = [E(x), log(x)+1, 1./x].
// pdMat may be an ifexplicit m x n matrix A (preferably sparse!),
// or a string containing the name of a function pdMat.m
// or a function_handle for such a function
// such that y = pdMat( name,mode,m,n,x )
// returns y = A*x (mode=1) or y = A"*x (mode=2).
// The input parameter "name" will be the string pdMat.
// b is an m-vector.
// bl is an n-vector of lower bounds. Non-existent bounds
// may be represented by bl(j) = -Inf or bl(j) <= -1e+20.
// bu is an n-vector of upper bounds. Non-existent bounds
// may be represented by bu(j) = Inf or bu(j) >= 1e+20.
// d1, d2 may be positive scalars or positive vectors (see above).
// options is a structure that may be set and altered by pdcoSet
// (type help pdcoSet).
// x0, y0, z0 provide an initial solution.
// xsize, zsize are estimates of the biggest x and z at the solution.
// They are used to scale (x,y,z). Good estimates
// should improve the performance of the barrier method.
//
//
// OUTPUT ARGUMENTS:
// x is the primal solution.
// y is the dual solution associated with Ax + D2 r = b.
// z is the dual solution associated with bl <= x <= bu.
// inform = 0 if a solution is found;
// = 1 if too many iterations were required;
// = 2 if the linesearch failed too often.
// PDitns is the number of Primal-Dual Barrier iterations required.
// CGitns is the number of Conjugate-Gradient iterations required
// if an iterative solver is used (LSQR).
// time is the cpu time used.
//----------------------------------------------------------------------
// PRIVATE FUNCTIONS:
// pdxxxbounds
// pdxxxdistrib
// pdxxxlsqr
// pdxxxlsqrmat
// pdxxxmat
// pdxxxmerit
// pdxxxresid1
// pdxxxresid2
// pdxxxstep
//
// GLOBAL VARIABLES:
// global pdDDD1 pdDDD2 pdDDD3
//
//
// NOTES:
// The matrix A should be reasonably well scaled: norm(A,inf) =~ 1.
// The vector b and objective phi(x) may be of any size, but ensure that
// xsize and zsize are reasonably close to norm(x,inf) and norm(z,inf)
// at the solution.
//
// The files defining pdObj and pdMat
// must not be called Fname.m or Aname.m!!
//
//
// AUTHOR:
// Michael Saunders, Systems Optimization Laboratory (SOL),
// Stanford University, Stanford, California, USA.
// [email protected]
//
// CONTRIBUTORS:
// Byunggyoo Kim, SOL, Stanford University.
// [email protected]
//
// DEVELOPMENT:
// 20 Jun 1997: Original version of pdsco.m derived from pdlp0.m.
// 29 Sep 2002: Original version of pdco.m derived from pdsco.m.
// Introduced D1, D2 in place of gamma*I, delta*I
// and allowed for general bounds bl <= x <= bu.
// 06 Oct 2002: Allowed for fixed variabes: bl(j) = bu(j) for any j.
// 15 Oct 2002: Eliminated some work vectors (since m, n might be LARGE).
// Modularized residuals, linesearch
// 16 Oct 2002: pdxxx..., pdDDD... names rationalized.
// pdAAA eliminated (global copy of A).
// Aname is now used directly as an ifexplicit A or a function.
// NOTE: If Aname is a function, it now has an extra parameter.
// 23 Oct 2002: Fname and Aname can now be function handles.
// 01 Nov 2002: Bug fixed in feval in pdxxxmat.
//-----------------------------------------------------------------------
// global pdDDD1 pdDDD2 pdDDD3
double inf = 1.0e30;
double eps = 1.0e-15;
double atolold = -1.0, r3ratio = -1.0, Pinf, Dinf, Cinf, Cinf0;
printf("\n --------------------------------------------------------");
printf("\n pdco.m Version of 01 Nov 2002");
printf("\n Primal-dual barrier method to minimize a convex function");
printf("\n subject to linear constraints Ax + r = b, bl <= x <= bu");
printf("\n --------------------------------------------------------\n");
int m = numberRows_;
int n = numberColumns_;
bool ifexplicit = true;
CoinDenseVector<double> b(m, rhs_);
CoinDenseVector<double> x(n, x_);
CoinDenseVector<double> y(m, y_);
CoinDenseVector<double> z(n, dj_);
//delete old arrays
delete [] rhs_;
delete [] x_;
delete [] y_;
delete [] dj_;
rhs_ = NULL;
x_ = NULL;
y_ = NULL;
dj_ = NULL;
// Save stuff so available elsewhere
pdcoStuff_ = stuff;
double normb = b.infNorm();
double normx0 = x.infNorm();
double normy0 = y.infNorm();
double normz0 = z.infNorm();
printf("\nmax |b | = %8g max |x0| = %8g", normb , normx0);
printf( " xsize = %8g", xsize_);
printf("\nmax |y0| = %8g max |z0| = %8g", normy0, normz0);
printf( " zsize = %8g", zsize_);
//---------------------------------------------------------------------
// Initialize.
//---------------------------------------------------------------------
//true = 1;
//false = 0;
//zn = zeros(n,1);
//int nb = n + m;
int CGitns = 0;
int inform = 0;
//---------------------------------------------------------------------
// Only allow scalar d1, d2 for now
//---------------------------------------------------------------------
/*
if (d1_->size()==1)
d1_->resize(n, d1_->getElements()[0]); // Allow scalar d1, d2
if (d2_->size()==1)
d2->resize(m, d2->getElements()[0]); // to mean dk * unit vector
*/
assert (stuff->sizeD1() == 1);
double d1 = stuff->getD1();
double d2 = stuff->getD2();
//---------------------------------------------------------------------
// Grab input options.
//---------------------------------------------------------------------
int maxitn = options.MaxIter;
double featol = options.FeaTol;
double opttol = options.OptTol;
double steptol = options.StepTol;
int stepSame = 1; /* options.StepSame; // 1 means stepx == stepz */
double x0min = options.x0min;
double z0min = options.z0min;
double mu0 = options.mu0;
int LSproblem = options.LSproblem; // See below
int LSmethod = options.LSmethod; // 1=Cholesky 2=QR 3=LSQR
int itnlim = options.LSQRMaxIter * CoinMin(m, n);
double atol1 = options.LSQRatol1; // Initial atol
double atol2 = options.LSQRatol2; // Smallest atol,unless atol1 is smaller
double conlim = options.LSQRconlim;
//int wait = options.wait;
// LSproblem:
// 1 = dy 2 = dy shifted, DLS
// 11 = s 12 = s shifted, DLS (dx = Ds)
// 21 = dx
// 31 = 3x3 system, symmetrized by Z^{1/2}
// 32 = 2x2 system, symmetrized by X^{1/2}
//---------------------------------------------------------------------
// Set other parameters.
//---------------------------------------------------------------------
int kminor = 0; // 1 stops after each iteration
double eta = 1e-4; // Linesearch tolerance for "sufficient descent"
double maxf = 10; // Linesearch backtrack limit (function evaluations)
double maxfail = 1; // Linesearch failure limit (consecutive iterations)
double bigcenter = 1e+3; // mu is reduced if center < bigcenter.
// Parameters for LSQR.
double atolmin = eps; // Smallest atol if linesearch back-tracks
double btol = 0; // Should be small (zero is ok)
double show = false; // Controls lsqr iteration log
/*
double gamma = d1->infNorm();
double delta = d2->infNorm();
*/
double gamma = d1;
double delta = d2;
printf("\n\nx0min = %8g featol = %8.1e", x0min, featol);
printf( " d1max = %8.1e", gamma);
printf( "\nz0min = %8g opttol = %8.1e", z0min, opttol);
printf( " d2max = %8.1e", delta);
printf( "\nmu0 = %8.1e steptol = %8g", mu0 , steptol);
printf( " bigcenter= %8g" , bigcenter);
printf("\n\nLSQR:");
printf("\natol1 = %8.1e atol2 = %8.1e", atol1 , atol2 );
printf( " btol = %8.1e", btol );
printf("\nconlim = %8.1e itnlim = %8d" , conlim, itnlim);
printf( " show = %8g" , show );
// LSmethod = 3; ////// Hardwire LSQR
// LSproblem = 1; ////// and LS problem defining "dy".
/*
if wait
printf("\n\nReview parameters... then type "return"\n")
keyboard
end
*/
if (eta < 0)
printf("\n\nLinesearch disabled by eta < 0");
//---------------------------------------------------------------------
// All parameters have now been set.
//---------------------------------------------------------------------
double time = CoinCpuTime();
//bool useChol = (LSmethod == 1);
//bool useQR = (LSmethod == 2);
bool direct = (LSmethod <= 2 && ifexplicit);
char solver[7];
strncpy(solver, " LSQR", 7);
//---------------------------------------------------------------------
// Categorize bounds and allow for fixed variables by modifying b.
//---------------------------------------------------------------------
int nlow, nupp, nfix;
int *bptrs[3] = {0};
getBoundTypes(&nlow, &nupp, &nfix, bptrs );
int *low = bptrs[0];
int *upp = bptrs[1];
int *fix = bptrs[2];
int nU = n;
if (nupp == 0) nU = 1; //Make dummy vectors if no Upper bounds
//---------------------------------------------------------------------
// Get pointers to local copy of model bounds
//---------------------------------------------------------------------
CoinDenseVector<double> bl(n, columnLower_);
double *bl_elts = bl.getElements();
CoinDenseVector<double> bu(nU, columnUpper_); // this is dummy if no UB
double *bu_elts = bu.getElements();
CoinDenseVector<double> r1(m, 0.0);
double *r1_elts = r1.getElements();
CoinDenseVector<double> x1(n, 0.0);
double *x1_elts = x1.getElements();
if (nfix > 0) {
for (int k = 0; k < nfix; k++)
x1_elts[fix[k]] = bl[fix[k]];
matVecMult(1, r1, x1);
b = b - r1;
// At some stage, might want to look at normfix = norm(r1,inf);
}
//---------------------------------------------------------------------
// Scale the input data.
// The scaled variables are
// xbar = x/beta,
// ybar = y/zeta,
// zbar = z/zeta.
// Define
// theta = beta*zeta;
// The scaled function is
// phibar = ( 1 /theta) fbar(beta*xbar),
// gradient = (beta /theta) grad,
// Hessian = (beta2/theta) hess.
//---------------------------------------------------------------------
double beta = xsize_;
if (beta == 0) beta = 1; // beta scales b, x.
double zeta = zsize_;
if (zeta == 0) zeta = 1; // zeta scales y, z.
double theta = beta * zeta; // theta scales obj.
// (theta could be anything, but theta = beta*zeta makes
// scaled grad = grad/zeta = 1 approximately if zeta is chosen right.)
for (int k = 0; k < nlow; k++)
bl_elts[low[k]] = bl_elts[low[k]] / beta;
for (int k = 0; k < nupp; k++)
bu_elts[upp[k]] = bu_elts[upp[k]] / beta;
d1 = d1 * ( beta / sqrt(theta) );
d2 = d2 * ( sqrt(theta) / beta );
double beta2 = beta * beta;
b.scale( (1.0 / beta) );
y.scale( (1.0 / zeta) );
x.scale( (1.0 / beta) );
z.scale( (1.0 / zeta) );
//---------------------------------------------------------------------
// Initialize vectors that are not fully used if bounds are missing.
//---------------------------------------------------------------------
CoinDenseVector<double> rL(n, 0.0);
CoinDenseVector<double> cL(n, 0.0);
CoinDenseVector<double> z1(n, 0.0);
CoinDenseVector<double> dx1(n, 0.0);
CoinDenseVector<double> dz1(n, 0.0);
CoinDenseVector<double> r2(n, 0.0);
// Assign upper bd regions (dummy if no UBs)
CoinDenseVector<double> rU(nU, 0.0);
CoinDenseVector<double> cU(nU, 0.0);
CoinDenseVector<double> x2(nU, 0.0);
CoinDenseVector<double> z2(nU, 0.0);
CoinDenseVector<double> dx2(nU, 0.0);
CoinDenseVector<double> dz2(nU, 0.0);
//---------------------------------------------------------------------
// Initialize x, y, z, objective, etc.
//---------------------------------------------------------------------
CoinDenseVector<double> dx(n, 0.0);
CoinDenseVector<double> dy(m, 0.0);
CoinDenseVector<double> Pr(m);
CoinDenseVector<double> D(n);
double *D_elts = D.getElements();
CoinDenseVector<double> w(n);
double *w_elts = w.getElements();
CoinDenseVector<double> rhs(m + n);
//---------------------------------------------------------------------
// Pull out the element array pointers for efficiency
//---------------------------------------------------------------------
double *x_elts = x.getElements();
double *x2_elts = x2.getElements();
double *z_elts = z.getElements();
double *z1_elts = z1.getElements();
double *z2_elts = z2.getElements();
for (int k = 0; k < nlow; k++) {
x_elts[low[k]] = CoinMax( x_elts[low[k]], bl[low[k]]);
x1_elts[low[k]] = CoinMax( x_elts[low[k]] - bl[low[k]], x0min );
z1_elts[low[k]] = CoinMax( z_elts[low[k]], z0min );
}
for (int k = 0; k < nupp; k++) {
x_elts[upp[k]] = CoinMin( x_elts[upp[k]], bu[upp[k]]);
x2_elts[upp[k]] = CoinMax(bu[upp[k]] - x_elts[upp[k]], x0min );
z2_elts[upp[k]] = CoinMax(-z_elts[upp[k]], z0min );
}
//////////////////// Assume hessian is diagonal. //////////////////////
// [obj,grad,hess] = feval( Fname, (x*beta) );
x.scale(beta);
double obj = getObj(x);
CoinDenseVector<double> grad(n);
getGrad(x, grad);
CoinDenseVector<double> H(n);
getHessian(x , H);
x.scale((1.0 / beta));
//double * g_elts = grad.getElements();
double * H_elts = H.getElements();
obj /= theta; // Scaled obj.
grad = grad * (beta / theta) + (d1 * d1) * x; // grad includes x regularization.
H = H * (beta2 / theta) + (d1 * d1) ; // H includes x regularization.
/*---------------------------------------------------------------------
// Compute primal and dual residuals:
// r1 = b - Aprod(x) - d2*d2*y;
// r2 = grad - Atprod(y) + z2 - z1;
// rL = bl - x + x1;
// rU = x + x2 - bu; */
//---------------------------------------------------------------------
// [r1,r2,rL,rU,Pinf,Dinf] = ...
// pdxxxresid1( Aname,fix,low,upp, ...
// b,bl,bu,d1,d2,grad,rL,rU,x,x1,x2,y,z1,z2 );
pdxxxresid1( this, nlow, nupp, nfix, low, upp, fix,
b, bl_elts, bu_elts, d1, d2, grad, rL, rU, x, x1, x2, y, z1, z2,
r1, r2, &Pinf, &Dinf);
//---------------------------------------------------------------------
// Initialize mu and complementarity residuals:
// cL = mu*e - X1*z1.
// cU = mu*e - X2*z2.
//
// 25 Jan 2001: Now that b and obj are scaled (and hence x,y,z),
// we should be able to use mufirst = mu0 (absolute value).
// 0.1 worked poorly on StarTest1 with x0min = z0min = 0.1.
// 29 Jan 2001: We might as well use mu0 = x0min * z0min;
// so that most variables are centered after a warm start.
// 29 Sep 2002: Use mufirst = mu0*(x0min * z0min),
// regarding mu0 as a scaling of the initial center.
//---------------------------------------------------------------------
// double mufirst = mu0*(x0min * z0min);
double mufirst = mu0; // revert to absolute value
double mulast = 0.1 * opttol;
mulast = CoinMin( mulast, mufirst );
double mu = mufirst;
double center, fmerit;
pdxxxresid2( mu, nlow, nupp, low, upp, cL, cU, x1, x2,
z1, z2, ¢er, &Cinf, &Cinf0 );
fmerit = pdxxxmerit(nlow, nupp, low, upp, r1, r2, rL, rU, cL, cU );
// Initialize other things.
bool precon = true;
double PDitns = 0;
//bool converged = false;
double atol = atol1;
atol2 = CoinMax( atol2, atolmin );
atolmin = atol2;
// pdDDD2 = d2; // Global vector for diagonal matrix D2
// Iteration log.
int nf = 0;
int itncg = 0;
int nfail = 0;
printf("\n\nItn mu stepx stepz Pinf Dinf");
printf(" Cinf Objective nf center");
if (direct) {
printf("\n");
} else {
printf(" atol solver Inexact\n");
}
double regx = (d1 * x).twoNorm();
double regy = (d2 * y).twoNorm();
// regterm = twoNorm(d1.*x)^2 + norm(d2.*y)^2;
double regterm = regx * regx + regy * regy;
double objreg = obj + 0.5 * regterm;
double objtrue = objreg * theta;
printf("\n%3g ", PDitns );
printf("%6.1f%6.1f" , log10(Pinf ), log10(Dinf));
printf("%6.1f%15.7e", log10(Cinf0), objtrue );
printf(" %8.1f\n" , center );
/*
if kminor
printf("\n\nStart of first minor itn...\n");
keyboard
end
*/
//---------------------------------------------------------------------
// Main loop.
//---------------------------------------------------------------------
// Lsqr
ClpLsqr thisLsqr(this);
// while (converged) {
while(PDitns < maxitn) {
PDitns = PDitns + 1;
// 31 Jan 2001: Set atol according to progress, a la Inexact Newton.
// 07 Feb 2001: 0.1 not small enough for Satellite problem. Try 0.01.
// 25 Apr 2001: 0.01 seems wasteful for Star problem.
// Now that starting conditions are better, go back to 0.1.
double r3norm = CoinMax(Pinf, CoinMax(Dinf, Cinf));
atol = CoinMin(atol, r3norm * 0.1);
atol = CoinMax(atol, atolmin );
info.r3norm = r3norm;
//-------------------------------------------------------------------
// Define a damped Newton iteration for solving f = 0,
// keeping x1, x2, z1, z2 > 0. We eliminate dx1, dx2, dz1, dz2
// to obtain the system
//
// [-H2 A" ] [ dx ] = [ w ], H2 = H + D1^2 + X1inv Z1 + X2inv Z2,
// [ A D2^2] [ dy ] = [ r1] w = r2 - X1inv(cL + Z1 rL)
// + X2inv(cU + Z2 rU),
//
// which is equivalent to the least-squares problem
//
// min || [ D A"]dy - [ D w ] ||, D = H2^{-1/2}. (*)
// || [ D2 ] [D2inv r1] ||
//-------------------------------------------------------------------
for (int k = 0; k < nlow; k++)
H_elts[low[k]] = H_elts[low[k]] + z1[low[k]] / x1[low[k]];
for (int k = 0; k < nupp; k++)
H[upp[k]] = H[upp[k]] + z2[upp[k]] / x2[upp[k]];
w = r2;
for (int k = 0; k < nlow; k++)
w[low[k]] = w[low[k]] - (cL[low[k]] + z1[low[k]] * rL[low[k]]) / x1[low[k]];
for (int k = 0; k < nupp; k++)
w[upp[k]] = w[upp[k]] + (cU[upp[k]] + z2[upp[k]] * rU[upp[k]]) / x2[upp[k]];
if (LSproblem == 1) {
//-----------------------------------------------------------------
// Solve (*) for dy.
//-----------------------------------------------------------------
H = 1.0 / H; // H is now Hinv (NOTE!)
for (int k = 0; k < nfix; k++)
H[fix[k]] = 0;
for (int k = 0; k < n; k++)
D_elts[k] = sqrt(H_elts[k]);
thisLsqr.borrowDiag1(D_elts);
thisLsqr.diag2_ = d2;
if (direct) {
// Omit direct option for now
} else {// Iterative solve using LSQR.
//rhs = [ D.*w; r1./d2 ];
for (int k = 0; k < n; k++)
rhs[k] = D_elts[k] * w_elts[k];
for (int k = 0; k < m; k++)
rhs[n+k] = r1_elts[k] * (1.0 / d2);
double damp = 0;
if (precon) { // Construct diagonal preconditioner for LSQR
matPrecon(d2, Pr, D);
}
/*
rw(7) = precon;
info.atolmin = atolmin;
info.r3norm = fmerit; // Must be the 2-norm here.
[ dy, istop, itncg, outfo ] = ...
pdxxxlsqr( nb,m,"pdxxxlsqrmat",Aname,rw,rhs,damp, ...
atol,btol,conlim,itnlim,show,info );
thisLsqr.input->rhs_vec = &rhs;
thisLsqr.input->sol_vec = &dy;
thisLsqr.input->rel_mat_err = atol;
thisLsqr.do_lsqr(this);
*/
// New version of lsqr
int istop;
dy.clear();
show = false;
info.atolmin = atolmin;
info.r3norm = fmerit; // Must be the 2-norm here.
thisLsqr.do_lsqr( rhs, damp, atol, btol, conlim, itnlim,
show, info, dy , &istop, &itncg, &outfo, precon, Pr);
if (precon)
dy = dy * Pr;
if (!precon && itncg > 999999)
precon = true;
if (istop == 3 || istop == 7 ) // conlim or itnlim
printf("\n LSQR stopped early: istop = //%d", istop);
atolold = outfo.atolold;
atol = outfo.atolnew;
r3ratio = outfo.r3ratio;
}// LSproblem 1
// grad = pdxxxmat( Aname,2,m,n,dy ); // grad = A"dy
grad.clear();
matVecMult(2, grad, dy);
for (int k = 0; k < nfix; k++)
grad[fix[k]] = 0; // grad is a work vector
dx = H * (grad - w);
} else {
perror( "This LSproblem not yet implemented\n" );
}
//-------------------------------------------------------------------
CGitns += itncg;
//-------------------------------------------------------------------
// dx and dy are now known. Get dx1, dx2, dz1, dz2.
//-------------------------------------------------------------------
for (int k = 0; k < nlow; k++) {
dx1[low[k]] = - rL[low[k]] + dx[low[k]];
dz1[low[k]] = (cL[low[k]] - z1[low[k]] * dx1[low[k]]) / x1[low[k]];
}
for (int k = 0; k < nupp; k++) {
dx2[upp[k]] = - rU[upp[k]] - dx[upp[k]];
dz2[upp[k]] = (cU[upp[k]] - z2[upp[k]] * dx2[upp[k]]) / x2[upp[k]];
}
//-------------------------------------------------------------------
// Find the maximum step.
//--------------------------------------------------------------------
double stepx1 = pdxxxstep(nlow, low, x1, dx1 );
double stepx2 = inf;
if (nupp > 0)
stepx2 = pdxxxstep(nupp, upp, x2, dx2 );
double stepz1 = pdxxxstep( z1 , dz1 );
double stepz2 = inf;
if (nupp > 0)
stepz2 = pdxxxstep( z2 , dz2 );
double stepx = CoinMin( stepx1, stepx2 );
double stepz = CoinMin( stepz1, stepz2 );
stepx = CoinMin( steptol * stepx, 1.0 );
stepz = CoinMin( steptol * stepz, 1.0 );
if (stepSame) { // For NLPs, force same step
stepx = CoinMin( stepx, stepz ); // (true Newton method)
stepz = stepx;
}
//-------------------------------------------------------------------
// Backtracking linesearch.
//-------------------------------------------------------------------
bool fail = true;
nf = 0;
while (nf < maxf) {
nf = nf + 1;
x = x + stepx * dx;
y = y + stepz * dy;
for (int k = 0; k < nlow; k++) {
x1[low[k]] = x1[low[k]] + stepx * dx1[low[k]];
z1[low[k]] = z1[low[k]] + stepz * dz1[low[k]];
}
for (int k = 0; k < nupp; k++) {
x2[upp[k]] = x2[upp[k]] + stepx * dx2[upp[k]];
z2[upp[k]] = z2[upp[k]] + stepz * dz2[upp[k]];
}
// [obj,grad,hess] = feval( Fname, (x*beta) );
x.scale(beta);
obj = getObj(x);
getGrad(x, grad);
getHessian(x, H);
x.scale((1.0 / beta));
obj /= theta;
grad = grad * (beta / theta) + d1 * d1 * x;
H = H * (beta2 / theta) + d1 * d1;
// [r1,r2,rL,rU,Pinf,Dinf] = ...
pdxxxresid1( this, nlow, nupp, nfix, low, upp, fix,
b, bl_elts, bu_elts, d1, d2, grad, rL, rU, x, x1, x2,
y, z1, z2, r1, r2, &Pinf, &Dinf );
//double center, Cinf, Cinf0;
// [cL,cU,center,Cinf,Cinf0] = ...
pdxxxresid2( mu, nlow, nupp, low, upp, cL, cU, x1, x2, z1, z2,
¢er, &Cinf, &Cinf0);
double fmeritnew = pdxxxmerit(nlow, nupp, low, upp, r1, r2, rL, rU, cL, cU );
double step = CoinMin( stepx, stepz );
if (fmeritnew <= (1 - eta * step)*fmerit) {
fail = false;
break;
}
// Merit function didn"t decrease.
// Restore variables to previous values.
// (This introduces a little error, but save lots of space.)
x = x - stepx * dx;
y = y - stepz * dy;
for (int k = 0; k < nlow; k++) {
x1[low[k]] = x1[low[k]] - stepx * dx1[low[k]];
z1[low[k]] = z1[low[k]] - stepz * dz1[low[k]];
}
for (int k = 0; k < nupp; k++) {
x2[upp[k]] = x2[upp[k]] - stepx * dx2[upp[k]];
z2[upp[k]] = z2[upp[k]] - stepz * dz2[upp[k]];
}
// Back-track.
// If it"s the first time,
// make stepx and stepz the same.
if (nf == 1 && stepx != stepz) {
stepx = step;
} else if (nf < maxf) {
stepx = stepx / 2;
}
stepz = stepx;
}
if (fail) {
printf("\n Linesearch failed (nf too big)");
nfail += 1;
} else {
nfail = 0;
}
//-------------------------------------------------------------------
// Set convergence measures.
//--------------------------------------------------------------------
regx = (d1 * x).twoNorm();
regy = (d2 * y).twoNorm();
regterm = regx * regx + regy * regy;
objreg = obj + 0.5 * regterm;
objtrue = objreg * theta;
bool primalfeas = Pinf <= featol;
bool dualfeas = Dinf <= featol;
bool complementary = Cinf0 <= opttol;
bool enough = PDitns >= 4; // Prevent premature termination.
bool converged = primalfeas & dualfeas & complementary & enough;
//-------------------------------------------------------------------
// Iteration log.
//-------------------------------------------------------------------
char str1[100], str2[100], str3[100], str4[100], str5[100];
sprintf(str1, "\n%3g%5.1f" , PDitns , log10(mu) );
sprintf(str2, "%8.5f%8.5f" , stepx , stepz );
if (stepx < 0.0001 || stepz < 0.0001) {
sprintf(str2, " %6.1e %6.1e" , stepx , stepz );
}
sprintf(str3, "%6.1f%6.1f" , log10(Pinf) , log10(Dinf));
sprintf(str4, "%6.1f%15.7e", log10(Cinf0), objtrue );
sprintf(str5, "%3d%8.1f" , nf , center );
if (center > 99999) {
sprintf(str5, "%3d%8.1e" , nf , center );
}
printf("%s%s%s%s%s", str1, str2, str3, str4, str5);
if (direct) {
// relax
} else {
printf(" %5.1f%7d%7.3f", log10(atolold), itncg, r3ratio);
}
//-------------------------------------------------------------------
// Test for termination.
//-------------------------------------------------------------------
if (kminor) {
printf( "\nStart of next minor itn...\n");
// keyboard;
}
if (converged) {
printf("\n Converged");
break;
} else if (PDitns >= maxitn) {
printf("\n Too many iterations");
inform = 1;
break;
} else if (nfail >= maxfail) {
printf("\n Too many linesearch failures");
inform = 2;
break;
} else {
// Reduce mu, and reset certain residuals.
double stepmu = CoinMin( stepx , stepz );
stepmu = CoinMin( stepmu, steptol );
double muold = mu;
mu = mu - stepmu * mu;
if (center >= bigcenter)
mu = muold;
// mutrad = mu0*(sum(Xz)/n); // 24 May 1998: Traditional value, but
// mu = CoinMin(mu,mutrad ); // it seemed to decrease mu too much.
mu = CoinMax(mu, mulast); // 13 Jun 1998: No need for smaller mu.
// [cL,cU,center,Cinf,Cinf0] = ...
pdxxxresid2( mu, nlow, nupp, low, upp, cL, cU, x1, x2, z1, z2,
¢er, &Cinf, &Cinf0 );
fmerit = pdxxxmerit( nlow, nupp, low, upp, r1, r2, rL, rU, cL, cU );
// Reduce atol for LSQR (and SYMMLQ).
// NOW DONE AT TOP OF LOOP.
atolold = atol;
// if atol > atol2
// atolfac = (mu/mufirst)^0.25;
// atol = CoinMax( atol*atolfac, atol2 );
// end
// atol = CoinMin( atol, mu ); // 22 Jan 2001: a la Inexact Newton.
// atol = CoinMin( atol, 0.5*mu ); // 30 Jan 2001: A bit tighter
// If the linesearch took more than one function (nf > 1),
// we assume the search direction needed more accuracy
// (though this may be true only for LPs).
// 12 Jun 1998: Ask for more accuracy if nf > 2.
// 24 Nov 2000: Also if the steps are small.
// 30 Jan 2001: Small steps might be ok with warm start.
// 06 Feb 2001: Not necessarily. Reinstated tests in next line.
if (nf > 2 || CoinMin( stepx, stepz ) <= 0.01)
atol = atolold * 0.1;
}
//---------------------------------------------------------------------
// End of main loop.
//---------------------------------------------------------------------
}
for (int k = 0; k < nfix; k++)
x[fix[k]] = bl[fix[k]];
z = z1;
if (nupp > 0)
z = z - z2;
printf("\n\nmax |x| =%10.3f", x.infNorm() );
printf(" max |y| =%10.3f", y.infNorm() );
printf(" max |z| =%10.3f", z.infNorm() );
printf(" scaled");
x.scale(beta);
y.scale(zeta);
z.scale(zeta); // Unscale x, y, z.
printf( "\nmax |x| =%10.3f", x.infNorm() );
printf(" max |y| =%10.3f", y.infNorm() );
printf(" max |z| =%10.3f", z.infNorm() );
printf(" unscaled\n");
time = CoinCpuTime() - time;
char str1[100], str2[100];
sprintf(str1, "\nPDitns =%10g", PDitns );
sprintf(str2, "itns =%10d", CGitns );
// printf( [str1 " " solver str2] );
printf(" time =%10.1f\n", time);
/*
pdxxxdistrib( abs(x),abs(z) ); // Private function
if (wait)
keyboard;
*/
//-----------------------------------------------------------------------
// End function pdco.m
//-----------------------------------------------------------------------
/* printf("Solution x values:\n\n");
for (int k=0; k<n; k++)
printf(" %d %e\n", k, x[k]);
*/
// Print distribution
double thresh[9] = { 0.00000001, 0.0000001, 0.000001, 0.00001, 0.0001, 0.001, 0.01, 0.1, 1.00001};
int counts[9] = {0};
for (int ij = 0; ij < n; ij++) {
for (int j = 0; j < 9; j++) {
if(x[ij] < thresh[j]) {
counts[j] += 1;
break;
}
}
}
printf ("Distribution of Solution Values\n");
for (int j = 8; j > 1; j--)
printf(" %g to %g %d\n", thresh[j-1], thresh[j], counts[j]);
printf(" Less than %g %d\n", thresh[2], counts[0]);
return inform;
}
void StrandBlockSolver::lhsDissipation()
{
int jj=nPstr+2,nn=nFaces+nBedges;
Array4D<double> aa(nq,nq,jj,nn);
for (int n=0; n<nFaces+nBedges; n++)
for (int j=0; j<nPstr+2; j++)
for (int k=0; k<nq; k++)
for (int l=0; l<nq; l++) aa(l,k,j,n) = 0.;
// unstructured faces
int c1,c2,n1,n2,jp,fc,m,mm,m1l,m1u,m2l,m2u,npts=1;
double a[nq*nq];
for (int n=0; n<nEdges; n++){
c1 = edge(0,n);
c2 = edge(1,n);
m1l = ncsc(c1 );
m1u = ncsc(c1+1);
m2l = ncsc(c2 );
m2u = ncsc(c2+1);
fc = fClip(c1);
if (fClip(c2) > fc) fc = fClip(c2);
for (int j=1; j<fc+1; j++){
sys->lhsDisFluxJacobian(npts,&facs(0,j,n),&xvs(j,n),
&q(0,j,c1),&q(0,j,c2),&a[0]);
for (int k=0; k<nq*nq; k++) a[k] *= .5;
// diagonal contributions
for (int k=0; k<nq; k++){
m = k*nq;
for (int l=0; l<nq; l++){
dd(l,k,j,c1) += a[m+l];
dd(l,k,j,c2) += a[m+l];
}}
// off-diagonal contributions
for (int k=0; k<nq; k++){
m = k*nq;
for (int l=0; l<nq; l++){
aa(l,k,j,c1) = a[m+l];
aa(l,k,j,c2) = a[m+l];
}}
for (int mm=m1l; mm<m1u; mm++){
nn = csc(mm);
for (int k=0; k<nq; k++){
m = k*nq;
for (int l=0; l<nq; l++)
bu(l,k,j,mm) -= aa(l,k,j,nn);
}}
for (int mm=m2l; mm<m2u; mm++){
nn = csc(mm);
for (int k=0; k<nq; k++){
m = k*nq;
for (int l=0; l<nq; l++)
bu(l,k,j,mm) -= aa(l,k,j,nn);
}}
// reset working array to zero
for (int k=0; k<nq; k++){
m = k*nq;
for (int l=0; l<nq; l++){
aa(l,k,j,c1) = 0.;
aa(l,k,j,c2) = 0.;
}}
}}
aa.deallocate();
// structured faces
double Ax,Ay,ds,eps=1.e-14;
for (int n=0; n<nFaces-nGfaces; n++){
n1 = face(0,n);
n2 = face(1,n);
for (int j=0; j<fClip(n)+1; j++){
jp = j+1;
Ax = facu(0,j,n);
Ay = facu(1,j,n);
ds = Ax*Ax+Ay*Ay;
if (fabs(ds) < eps){
for (int k=0; k<nq; k++){
m = k*nq;
for (int l=0; l<nq; l++)
a[m+l] = 0.;
}}
else
sys->lhsDisFluxJacobian(npts,&facu(0,j,n),&xvu(j,n),
&q(0,j,n),&q(0,jp,n),&a[0]);
for (int k=0; k<nq; k++){
m = k*nq;
for (int l=0; l<nq; l++){
dd(l,k,j ,n) += (a[m+l]*.5);
dp(l,k,j ,n) -= (a[m+l]*.5);
dd(l,k,jp,n) += (a[m+l]*.5);
dm(l,k,jp,n) -= (a[m+l]*.5);
}}}}
}
void RestorationProblem::printVariables( const Matrix &xi, const Matrix &lambda, int verbose )
{
int k;
printf("\n<|----- Original Variables -----|>\n");
for( k=0; k<parent->nVar; k++ )
//printf("%7i: %-30s %7g <= %10.3g <= %7g | mul=%10.3g\n", k+1, parent->varNames[k], bl(k), xi(k), bu(k), lambda(k));
printf("%7i: x%-5i %7g <= %10.3g <= %7g | mul=%10.3g\n", k+1, k, bl(k), xi(k), bu(k), lambda(k));
printf("\n<|----- Slack Variables -----|>\n");
for( k=parent->nVar; k<nVar; k++ )
printf("%7i: slack %7g <= %10.3g <= %7g | mul=%10.3g\n", k+1, bl(k), xi(k), bu(k), lambda(k));
}
void RestorationProblem::printConstraints( const Matrix &constr, const Matrix &lambda )
{
printf("\n<|----- Constraints -----|>\n");
for( int k=0; k<nCon; k++ )
//printf("%5i: %-30s %7g <= %10.4g <= %7g | mul=%10.3g\n", k+1, parent->conNames[parent->nVar+k], bl(nVar+k), constr(k), bu(nVar+k), lambda(nVar+k));
printf("%5i: c%-5i %7g <= %10.4g <= %7g | mul=%10.3g\n", k+1, k, bl(nVar+k), constr(k), bu(nVar+k), lambda(nVar+k));
}
int main(int argc, char *argv[])
{
int n = 15;
int m = 18;
std::vector<double> bl(n+m);
std::vector<double> bu(n+m);
double inf = 1.0e+20;
std::fill(bl.begin(), bl.begin()+n, 0);
std::fill(bu.begin(), bu.begin()+n, inf);
// http://apmonitor.com/wiki/uploads/Apps/hs118.apm
// LBX
bl[0] = 8.0;
bu[0] = 21.0;
bl[1] = 43.0;
bu[1] = 57.0;
bl[2] = 3.0;
bu[2] = 16.0;
bu[3] = 90.0;
bu[4] = 120.0;
bu[5] = 60.0;
bu[6] = 90.0;
bu[7] = 120.0;
bu[8] = 60.0;
bu[9] = 90.0;
bu[10] = 120.0;
bu[11] = 60.0;
bu[12] = 90.0;
bu[13] = 120.0;
bu[14] = 60.0;
//
std::fill(bl.begin()+n, bl.begin()+n+m, 0);
std::fill(bu.begin()+n, bu.begin()+n+m, inf);
//iObj = 18 means the linear objective is row 18 in valA(*).
//The objective row is free.
int iObj = 17;
bl[n+iObj] = -inf;
// LBG
bl[n+0] = -7.0;
bu[n+0] = 6.0;
bl[n+1] = -7.0;
bu[n+1] = 6.0;
bl[n+2] = -7.0;
bu[n+2] = 6.0;
bl[n+3] = -7.0;
bu[n+3] = 6.0;
bl[n+4] = -7.0;
bu[n+4] = 7.0;
bl[n+5] = -7.0;
bu[n+5] = 7.0;
bl[n+6] = -7.0;
bu[n+6] = 7.0;
bl[n+7] = -7.0;
bu[n+7] = 7.0;
bl[n+8] = -7.0;
bu[n+8] = 6.0;
bl[n+9] = -7.0;
bu[n+9] = 6.0;
bl[n+10] = -7.0;
bu[n+10] = 6.0;
bl[n+11] = -7.0;
bu[n+11] = 6.0;
bl[n+12] = 60.0;
bl[n+13] = 50.0;
bl[n+14] = 70.0;
bl[n+15] = 85.0;
bl[n+16] = 100.0;
std::vector<double> x0(n);
x0[ 0] = 20.0;
x0[ 1] = 55.0;
x0[ 2] = 15.0;
x0[ 3] = 20.0;
x0[ 4] = 60.0;
x0[ 5] = 20.0;
x0[ 6] = 20.0;
x0[ 7] = 60.0;
x0[ 8] = 20.0;
x0[9] = 20.0;
x0[10] = 60.0;
x0[11] = 20.0;
x0[12] = 20.0;
x0[13] = 60.0;
x0[14] = 20.0;
sqic(&m , &n, &bl[0], &bu[0]);
return 0;
}
/**
* \fn void point( double u , double v , double& x , double& y , double& z ) const
*
* \brief Compute a point on this rectangular Bezier patch.
*
* \param u First Cartesian coordinate of the parameter point.
* \param v Second Cartesian coordinate of the parameter point.
* \param x First Cartesian coordinate of the point on the patch.
* \param y Second Caresian coordinate of the point on the patch.
* \param z Third Cartesian coordinate of the point on the patch.
*/
void
tBezier::point(
double u ,
double v ,
double& x ,
double& y ,
double& z
)
const
{
/**
* Map the point to the affine frame [0,1].
*/
double rx = get_aff_1st_point_x_coord() ;
double ry = get_aff_1st_point_y_coord() ;
double sx = get_aff_2nd_point_x_coord() ;
double sy = get_aff_2nd_point_y_coord() ;
/**
* Compute all Bernstein polynomials of degree \var{_m}.
*/
double uu = ( u - rx ) / ( sx - rx ) ;
double vv = ( v - ry ) / ( sy - ry ) ;
if ( fabs( uu ) <= 1e-15 ) {
uu = 0 ;
}
else if ( fabs( 1 - uu ) <= 1e-15 ) {
uu = 1 ;
}
if ( fabs( vv ) <= 1e-15 ) {
vv = 0 ;
}
else if ( fabs( 1 - vv ) <= 1e-15 ) {
vv = 1 ;
}
unsigned m = get_bidegree_1st_index() ;
unsigned n = get_bidegree_2nd_index() ;
std::vector< double > bu( m + 1 ) ;
all_bernstein( m , uu , bu );
/**
* Compute all Bernstein polynomials of degree \var{_n}.
*/
std::vector< double > bv( n + 1 ) ;
all_bernstein( n , vv , bv );
/**
* Compute the image point, (x,y,z), of (u,v) on this patch.
*/
x = 0 ;
y = 0 ;
z = 0 ;
for ( unsigned j = 0 ; j <= n ; j++ ) {
for ( unsigned i = 0 ; i <= m ; i++ ) {
double buv = bu[ i ] * bv[ j ] ;
double xaux ;
double yaux ;
double zaux ;
b( i , j , xaux , yaux , zaux ) ;
x += buv * xaux ;
y += buv * yaux ;
z += buv * zaux ;
}
}
return ;
}
void CFiletransferContainer::UpdateDimensions(const TRect& aRect)
{
iRect=aRect;
iWidth=aRect.Width();
iMargin=iWidth/KMarginRatio;
iVerticalDistance=aRect.Height()/7;
if(iVerticalDistance>50)
iVerticalDistance=50;
iRound=iVerticalDistance/5; //was 3 before
iHorizontalDistance=iWidth-iMargin-iMargin;
iVD4=iVerticalDistance*4;
iVD5=iVerticalDistance*5;
iFill.Create(TSize(1,iVerticalDistance),EColor16MU);
TBitmapUtil bu(&iFill);
bu.Begin(TPoint(0,0));
TInt i;
for(i=0;i<iVerticalDistance;i++)
{
bu.SetPixel(0x00FF00-0x500*i);
bu.IncYPos();
};
//rectangles
TInt totHrz=iMargin;
TReal hrz=0;
TRect *rect;
iRects.ResetAndDestroy(); //we will append new elements
//compute the distance between rectangles
TInt averageRectangleLength=iHorizontalDistance/iFiletransferView->iTotalFilesNo;
if(averageRectangleLength<5)
{
//we should have a single rectangle, and not one rectangle for each file
//iRects.Count() will be one, but iDistanceBetweenRectangles is negative
iDistanceBetweenRectangles=-1;
//
rect=new(ELeave) TRect(totHrz,iVD4,totHrz+iHorizontalDistance,iVD5);
iRects.Append(rect);
}
else
{
iDistanceBetweenRectangles=2; //this is what we will use if there are not so many rectangles
if(averageRectangleLength<20)iDistanceBetweenRectangles=1;
if(averageRectangleLength<10)iDistanceBetweenRectangles=0;
TInt remainingBytes=iFiletransferView->iTotalBytes2Transfer;
TInt remainingHorizontalDistance=iHorizontalDistance;
for(i=0;i<iFiletransferView->iTotalFilesNo;i++)
{
totHrz+=(TInt)hrz;//hrz was computed in the last cycle
//hrz=iFiletransferView->iFileSizes[i]/(TReal)iFiletransferView->iTotalBytes2Transfer*iHorizontalDistance;
hrz=iFiletransferView->iFileSizes[i]/(TReal)remainingBytes*remainingHorizontalDistance;
remainingBytes-=iFiletransferView->iFileSizes[i];
remainingHorizontalDistance-=(TInt)hrz;
rect=new(ELeave) TRect(totHrz,iVD4,totHrz+(TInt)hrz-iDistanceBetweenRectangles,iVD5);
iRects.Append(rect);
};
}
}
int main(void){
//PRUEBA CLASE EDGE:
/*
Edge arista(1,2,0.65);
cout << arista.Weight() <<" "<< arista.either() <<" "<< arista.other(1) << endl;
arista.toString();
MiBag bolsa;
bolsa.add(arista);
bolsa.iterate_Edge();*/
/*
//PRUEBA CLASE WEIGHTEDGRAPH
EdgeWeightedGraph mi_grafo(5);
Edge arista(1,2,0.65);
Edge arista1(1,3,0.64);
Edge arista2(4,2,0.70);
Edge arista3(1,4,0.32);
Edge arista4(3,0,0.3);
Edge arista5(0,2,0.1);
mi_grafo.addEdge(arista);
mi_grafo.addEdge(arista1);
mi_grafo.addEdge(arista2);
mi_grafo.addEdge(arista3);
mi_grafo.addEdge(arista4);
mi_grafo.addEdge(arista5);
*/
// INICIO DE PRUEBA LAZY PRIM MST
int V,E;
ifstream fin("tinyEW.txt");
//ifstream fin("1000EWG.txt");
//ifstream fin("mediumEWG.txt");
char vertex[255];
char edges[255];
fin.getline(vertex,255);//lee la primera linea
fin.getline(edges,255);//lee la segunda linea
string Ve(vertex);
string Ed(edges);
istringstream bv(Ve);
istringstream be(Ed);
bv>>V;
be>>E;
char line[255];
//MinIndexedPQ pq(E);//prueba
EdgeWeightedGraph mi_grafo(V);
int u,v;
float w;
for (int i = 0; i<E; i++){
fin.getline(line,255);
string s(line);
vector <string> fields;
boost::algorithm::split(fields, s, boost::algorithm::is_any_of(" "));
istringstream bu(fields[0]);
bu>>u;
//cout<<u<<" ";
istringstream bv(fields[1]);
bv>>v;
//cout<<v<<" ";
istringstream bw(fields[2]);
bw>>w;
//cout<<w<<" ";
//cout<<" "<<endl;
Edge e(u,v,w);
/*float u = e.weight();
*/mi_grafo.addEdge(e);
}
//PRUEBA DE PRIORITY QUEUE QUE ALMACENA TODOS LOS EDGES:
/*priority_queue<Edge, vector<Edge>, CompareEdges> pq = mi_grafo.priorityQueue();
while(!pq.empty()){
Edge e = pq.top();
e.toString();
pq.pop();
}*/
//PRUEBAS DE ALGORITMOS:
cout<<"El MST Eager Prim:"<<endl;
EagerPrimMST mst1(mi_grafo);
mst1.printMST();
cout<<"El MST Lazy Prim:"<<endl;
LazyPrimMST mst2(mi_grafo);
mst2.printMST();
cout<<"El MST Kruskal:"<<endl;
kruskalMST mst3(mi_grafo);
mst3.printMST();
//cout<<"El peso total del MST es: "<<mst.weight()<<endl;
return 0;
}
