void accumQuery(const BlockVector<G1>& query,
const std::size_t reserveTune,
ProgressCallback* callback = nullptr)
{
std::size_t startOffset = 0;
if (0 == query.block()[0]) {
#ifdef USE_ASSERT
assert(query.size() >= 4);
#endif
m_val = m_val
+ (*m_random_d1) * query[0]
+ (*m_random_d2) * query[1]
+ (*m_random_d3) * query[2]
+ query[3];
startOffset = 4;
}
m_val = m_val + multiExp01(
query,
startOffset,
4,
*m_witness,
0 == reserveTune ? reserveTune : (query.size() - startOffset) / reserveTune,
callback);
}
void PrintBlockVector(const BlockVector& v,ostream& out,char delim,char bracket)
{
char closebracket = CloseBracket(bracket);
if(bracket) out<<bracket;
for(size_t i=0;i<v.size();i++) {
for(int j=0;j<v[i].n;j++)
out<<v[i](j)<<delim;
if(i+1 != v.size())
out<<'|';
}
if(closebracket) out<<closebracket;
}
void computeh(double time, BlockVector& q0, SiconosVector& y)
{
std::cout <<"my_NewtonEulerR:: computeh" << std:: endl;
std::cout <<"q0.size() = " << q0.size() << std:: endl;
double height = q0.getValue(0) - _sBallRadius - q0.getValue(7);
// std::cout <<"my_NewtonEulerR:: computeh _jachq" << std:: endl;
// _jachq->display();
y.setValue(0, height);
_Nc->setValue(0, 1);
_Nc->setValue(1, 0);
_Nc->setValue(2, 0);
_Pc1->setValue(0, q0.getValue(0) - _sBallRadius);
_Pc1->setValue(1, q0.getValue(1));
_Pc1->setValue(2, q0.getValue(2));
_Pc2->setValue(0,q0.getValue(7));
_Pc2->setValue(1,q0.getValue(8));
_Pc2->setValue(2,q0.getValue(9));
//printf("my_NewtonEulerR N, Pc\n");
_Nc->display();
_Pc1->display();
_Pc2->display();
std::cout <<"my_NewtonEulerR:: computeh ends" << std:: endl;
}
void FirstOrderLinearR::computeg(double time, SiconosVector& lambda, SiconosVector& z, BlockVector& r)
{
if (_pluginJacglambda->fPtr)
{
if (!_B)
_B.reset(new SimpleMatrix(r.size(),lambda.size()));
computeB(time, z, *_B);
}
prod(*_B, lambda, r, false);
}
// Copy from BlockVector
SiconosVector::SiconosVector(const BlockVector & vIn) : std11::enable_shared_from_this<SiconosVector>()
{
if (ask<IsDense>(**(vIn.begin()))) // dense
{
_dense = true;
vect.Dense = new DenseVect(vIn.size());
}
else
{
_dense = false;
vect.Sparse = new SparseVect(vIn.size());
}
VectorOfVectors::const_iterator it;
unsigned int pos = 0;
for (it = vIn.begin(); it != vIn.end(); ++it)
{
setBlock(pos, **it);
pos += (*it)->size();
}
}
// Quantise a subband in in-place transform order
// This version of quantise_subbands assumes multiple quantisers per subband.
// It may be used for either quantising slices or for quantising subbands with codeblocks
const Array2D quantise_subbands(const Array2D& coefficients, const BlockVector& qIndices) {
const Index transformHeight = coefficients.shape()[0];
const Index transformWidth = coefficients.shape()[1];
// TO DO: Check numberOfSubbands=3n+1 ?
const int numberOfSubbands = qIndices.size();
const int waveletDepth = (numberOfSubbands-1)/3;
Index stride, offset; // stride is subsampling factor, offset is subsampling phase
Array2D result(coefficients.ranges());
// Create a view of the coefficients, representing the LL subband, quantise it,
// then assign the result a view of the results array. This puts the quantised
// LL subband into the result array in in-place transform order.
// ArrayIndices2D objects specify the subset of array elements within a view,
// that is they specify the subsampling factor and subsampling phase.
stride = pow(2, waveletDepth);
const ArrayIndices2D LLindices = // LLindices specifies the samples in the LL subband
indices[Range(0,transformHeight,stride)][Range(0,transformWidth,stride)];
result[LLindices] =
quantise_LLSubband(coefficients[LLindices], qIndices[0]);
// Next quantise the other subbands
// Note: Level numbers go from zero for the lowest ("DC") frequencies to depth for
// the high frequencies. This corresponds to the convention in the VC-2 specification.
// Subands go from zero ("DC") to numberOfSubbands-1 for HH at the highest level
for (char level=1, band=1; level<=waveletDepth; ++level) {
stride = pow(2, waveletDepth+1-level);
offset = stride/2;
// Create a view of coefficients corresponding to a subband, then quantise it
//Quantise HL subband
const ArrayIndices2D HLindices = // HLindices specifies the samples in the HL subband
indices[Range(0,transformHeight,stride)][Range(offset,transformWidth,stride)];
result[HLindices] = quantise_block(coefficients[HLindices], qIndices[band++]);
//Quantise LH subband
const ArrayIndices2D LHindices = // LHindices specifies the samples in the LH subband
indices[Range(offset,transformHeight,stride)][Range(0,transformWidth,stride)];
result[LHindices] = quantise_block(coefficients[LHindices], qIndices[band++]);
//Quantise HH subband
const ArrayIndices2D HHindices = // HHindices specifies the samples in the HH subband
indices[Range(offset,transformHeight,stride)][Range(offset,transformWidth,stride)];
result[HHindices] = quantise_block(coefficients[HHindices], qIndices[band++]);
}
return result;
}
void FirstOrderLinearR::computeh(double time, BlockVector& x, SiconosVector& lambda,
SiconosVector& z, SiconosVector& y)
{
y.zero();
if (_pluginJachx->fPtr)
{
if (!_C)
_C.reset(new SimpleMatrix(y.size(),x.size()));
computeC(time, z, *_C);
}
if (_pluginJachlambda->fPtr)
{
if (!_D)
_D.reset(new SimpleMatrix(y.size(),lambda.size()));
computeD(time, z, *_D);
}
if (_pluginf->fPtr)
{
if (!_F)
_F.reset(new SimpleMatrix(y.size(),z.size()));
computeF(time, z, *_F);
}
if (_plugine->fPtr)
{
if (!_e)
_e.reset(new SiconosVector(y.size()));
computee(time, z, *_e);
}
if (_C)
prod(*_C, x, y, false);
if (_D)
prod(*_D, lambda, y, false);
if (_e)
y += *_e;
if (_F)
prod(*_F, z, y, false);
}
/** Extract the master block from <code>problem</code>.
* The constructor also sets up the solver for the newly created master
* block. The master block can only be extracted if all sub-blocks have
* already been extracted.
* @param problem The problem from which to extract the master.
* @param blocks The sub blocks that have already been extracted.
*/
BendersOpt::Block::Block(Problem const *problem, BlockVector const &blocks)
: env(), number(-1), vars(0), rows(0), cplex(0), cb(0)
{
IloNumVarArray problemVars = problem->getVariables();
IloRangeArray problemRanges = problem->getRows();
IloExpr masterObj(env);
IloNumVarArray masterVars(env);
IloRangeArray masterRows(env);
// Find columns that do not intersect block variables and
// copy them to the master block.
IdxMap idxMap;
RowSet rowSet;
for (IloInt j = 0; j < problemVars.getSize(); ++j) {
IloNumVar x = problemVars[j];
if ( problem->getBlock(x) < 0 ) {
// Column is not in a block. Copy it to the master.
IloNumVar v(env, x.getLB(), x.getUB(), x.getType(), x.getName());
varMap.insert(VarMap::value_type(v, x));
masterObj += problem->getObjCoef(x) * v;
idxMap[x] = masterVars.getSize();
masterVars.add(v);
}
else {
// Column is in a block. Collect all rows that intersect
// this column.
RowSet const &intersected = problem->getIntersectedRows(x);
for (RowSet::const_iterator it = intersected.begin();
it != intersected.end(); ++it)
rowSet.insert(*it);
idxMap[x] = -1;
}
}
// Pick up the rows that we need to copy.
// These are the rows that are only intersected by master variables,
// that is, the rows that are not in any block's rowset.
for (IloInt i = 0; i < problemRanges.getSize(); ++i) {
IloRange r = problemRanges[i];
if ( rowSet.find(r) == rowSet.end() ) {
IloRange masterRow(env, r.getLB(), r.getUB(), r.getName());
IloExpr lhs(env);
for (IloExpr::LinearIterator it = r.getLinearIterator(); it.ok(); ++it)
{
lhs += it.getCoef() * masterVars[idxMap[it.getVar()]];
}
masterRow.setExpr(lhs);
masterRows.add(masterRow);
}
}
// Adjust variable indices in blocks so that reference to variables
// in the original problem become references to variables in the master.
for (BlockVector::const_iterator b = blocks.begin(); b != blocks.end(); ++b) {
for (std::vector<FixData>::iterator it = (*b)->fixed.begin(); it != (*b)->fixed.end(); ++it)
it->col = idxMap[problemVars[it->col]];
}
// Create the eta variables, one for each block.
// See the comments at the top of this file for details about the
// eta variables.
IloInt const firsteta = masterVars.getSize();
for (BlockVector::size_type i = 0; i < blocks.size(); ++i) {
std::stringstream s;
s << "_eta" << i;
IloNumVar eta(env, 0.0, IloInfinity, s.str().c_str());
masterObj += eta;
masterVars.add(eta);
}
// Create model and solver instance
vars = masterVars;
rows = masterRows;
IloModel model(env);
model.add(obj = IloObjective(env, masterObj, problem->getObjSense()));
model.add(vars);
model.add(rows);
cplex = IloCplex(model);
cplex.use(cb = new (env) LazyConstraintCallback(env, this, blocks,
firsteta));
for (IloExpr::LinearIterator it = obj.getLinearIterator(); it.ok(); ++it)
objMap.insert(ObjMap::value_type(it.getVar(), it.getCoef()));
}
// Template specialization for BasicBlock.
template <> void dumpVector(const BlockVector &toDump) {
errs() << "Size: " << toDump.size() << "\n";
for (auto element : toDump)
errs() << element->getName() << " -- ";
errs() << "\n";
}