// Create launcher button toggleLauncherButton->setViewType("icon"); toggleLauncherButton->setObjectName("ToggleLauncherButton"); toggleLauncherButton->setIconID("icon-m-quicklaunchbar-menu-open"); connect(toggleLauncherButton, SIGNAL(clicked()), controller, SIGNAL(toggleLauncherButtonClicked())); // Put the stuff into a layout l->addStretch(); l->addItem(launcherButtonLayout); l->addStretch(); } QuickLaunchBarView::~QuickLaunchBarView() { // remove buttons from layout to avoid multi deletion (buttons are in model as QSharedPointer's) foreach (QSharedPointer<LauncherButton> button, model()->buttons().values()) { launcherButtonLayout->removeItem(button.data()); button->setParentItem(0); } } void QuickLaunchBarView::setupModel() { MWidgetView::setupModel(); QList<const char *> modifications; modifications << QuickLaunchBarModel::Buttons; updateData(modifications); } void QuickLaunchBarView::updateData(const QList<const char *>& modifications) {

const QStandardItemModel *FlagsComboBox::standardItemModel() const { return static_cast<const QStandardItemModel *>(model()); }

/*! \brief Assign a specific FX Channel for this track */ void SampleTrackView::assignFxLine(int channelIndex) { model()->effectChannelModel()->setValue(channelIndex); gui->fxMixerView()->setCurrentFxLine(channelIndex); }

void KateCompletionTree::resizeColumnsSlot() { if (model()) { resizeColumns(); } }

KateCompletionModel *KateCompletionTree::kateModel() const { return static_cast<KateCompletionModel *>(model()); }

surface::instance_t make(const description_t& description) { BOOST_LOG_TRIVIAL(debug) << "Make surface sor"; const auto& points = description.points; spline_t spline = make_spline(points.begin(), points.end()); derivations_t derivations; rtree_t rtree; for (std::size_t i = 0; i < spline.size(); ++i) { const spline_segment_t& segment = spline[i]; const polynomial5_t derivation = differentiate(std::get<2>(segment) * std::get<2>(segment)); const float delta = std::get<1>(segment) - std::get<0>(segment); float max = std::max ( evaluate(std::get<2>(segment), 0.0f), evaluate(std::get<2>(segment), delta) ); std::array<float, 5> roots; const auto end = solve(derivation, roots.begin()); for (auto root = roots.begin(); root != end; ++root) if (*root >= 0.0f && *root <= delta) max = std::max ({ max, evaluate(std::get<2>(segment), *root) }); const box_t box ( point_t(-max, std::get<0>(segment), -max), point_t(+max, std::get<1>(segment), +max) ); derivations.emplace_back(derivation); rtree.insert(value_t(box, i)); } /* const box_t box = transform ( description.transformation, box_t// TODO: puke => ( vector_t { geo::get<X>(rtree.bounds().min_corner()), geo::get<Y>(rtree.bounds().min_corner()), geo::get<Z>(rtree.bounds().min_corner()) }, vector_t { geo::get<X>(rtree.bounds().max_corner()), geo::get<Y>(rtree.bounds().max_corner()), geo::get<Z>(rtree.bounds().max_corner()) } ) ); BOOST_LOG_TRIVIAL(trace) << "Box: min = " << box.min_corner() << ", max = " << box.max_corner() << std::endl; const box_t box// TODO: puke => ( vector_t { geo::get<X>(rtree.bounds().min_corner()), geo::get<Y>(rtree.bounds().min_corner()), geo::get<Z>(rtree.bounds().min_corner()) }, vector_t { geo::get<X>(rtree.bounds().max_corner()), geo::get<Y>(rtree.bounds().max_corner()), geo::get<Z>(rtree.bounds().max_corner()) } ); BOOST_LOG_TRIVIAL(trace) << "Box: min = " << box.min_corner() << ", max = " << box.max_corner() << std::endl; */ model_t model ( std::move(spline), std::move(derivations), std::move(rtree), points.front()[X], points.back()[X], points.front()[Y], points.back()[Y] // box ); return std::make_shared<instance_impl_t<model_t>>(description.transformation, std::move(model)); // return boost::make_tuple // ( // primitive::make<model> // ( // description.transformation, // std::move(spline), // std::move(derivations), // std::move(rtree), // points.front()[X], // points.back()[X], // points.front()[Y], // points.back()[Y] // ), // box, // 3 * spline.size() + 2 // ); }

int run(const boost::mpi::communicator& comm, skylark::base::context_t& context, hilbert_options_t& options) { int rank = comm.rank(); InputType X, Xv, Xt; LabelType Y, Yv, Yt; if(!options.trainfile.empty()) { //training mode read(comm, options.fileformat, options.trainfile, X, Y); int dimensions = skylark::base::Height(X); int targets = GetNumTargets<LabelType>(comm, Y); bool shift = false; if ((options.lossfunction == LOGISTIC) && (targets == 1)) { ShiftForLogistic(Y); targets = 2; shift = true; } BlockADMMSolver<InputType>* Solver = GetSolver<InputType>(context, options, dimensions); if(!options.valfile.empty()) { comm.barrier(); if(rank == 0) std::cout << "Loading validation data." << std::endl; read(comm, options.fileformat, options.valfile, Xv, Yv, skylark::base::Height(X)); if ((options.lossfunction == LOGISTIC) && shift) { ShiftForLogistic(Yv); } } skylark::ml::model_t<InputType, LabelType>* model = Solver->train(X, Y, Xv, Yv, comm); if (comm.rank() == 0) model->save(options.modelfile, options.print()); } else { std::cout << "Testing Mode (currently loads test data in memory)" << std::endl; skylark::ml::model_t<InputType, LabelType> model(options.modelfile); read(comm, options.fileformat, options.testfile, Xt, Yt, model.get_input_size()); LabelType DecisionValues(Yt.Height(), model.get_num_outputs()); LabelType PredictedLabels(Yt.Height(), 1); El::Zero(DecisionValues); El::Zero(PredictedLabels); std::cout << "Starting predictions" << std::endl; model.predict(Xt, PredictedLabels, DecisionValues, options.numthreads); double accuracy = model.evaluate(Yt, DecisionValues, comm); if(rank == 0) std::cout << "Test Accuracy = " << accuracy << " %" << std::endl; // fix logistic case -- provide mechanism to dump predictions -- clean up evaluate } return 0; }

/** 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())); }

void InstrumentTrackView::activityIndicatorPressed() { model()->processInEvent( MidiEvent( MidiNoteOn, 0, DefaultKey, MidiDefaultVelocity ) ); }

void ExtractGameobjectModels() { Constants::ToWoWCoords = true; printf("Extracting GameObject models\n"); std::string baseBuildingsPath = "Buildings/"; std::string baseVmapsPath = "vmaps/"; Utils::CreateDir(baseVmapsPath); Utils::CreateDir(baseBuildingsPath); FILE* modelList = fopen((baseVmapsPath + "GameObjectModels.list").c_str(), "wb"); if (!modelList) { printf("Could not create file vmaps/GameObjectModels.list, please make sure that you have the write permissions in the folder\n"); return; } DBC* dbc = MPQHandler->GetDBC("GameObjectDisplayInfo"); for (std::vector<Record*>::iterator itr = dbc->Records.begin(); itr != dbc->Records.end(); ++itr) { std::string path = (*itr)->GetString(1); std::string fileName = Utils::GetPlainName(path.c_str()); std::string extension = Utils::GetExtension(fileName); // Convert the extension to lowercase std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower); if (extension == "mdx" || extension == "m2") { fileName = Utils::FixModelPath(fileName); Model model(path); if (model.IsBad) continue; FILE* output = fopen((baseBuildingsPath + fileName).c_str(), "wb"); if (!output) { printf("Could not create file %s, please check that you have write permissions\n", (baseBuildingsPath + fileName).c_str()); continue; } // Placeholder for 0 values int Nop[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; fwrite(Constants::VMAPMagic, 8, 1, output); uint32 numVerts = model.Header.CountBoundingVertices; fwrite(&numVerts, sizeof(uint32), 1, output); uint32 numGroups = 1; fwrite(&numGroups, sizeof(uint32), 1, output); fwrite(Nop, 4 * 3 , 1, output); // rootwmoid, flags, groupid fwrite(Nop, sizeof(float), 3 * 2, output);//bbox, only needed for WMO currently fwrite(Nop, 4, 1, output);// liquidflags fwrite("GRP ", 4, 1, output); uint32 branches = 1; uint32 wsize = sizeof(branches) + sizeof(uint32) * branches; fwrite(&wsize, sizeof(uint32), 1, output); fwrite(&branches, sizeof(branches), 1, output); uint32 numTris = model.Header.CountBoundingTriangles; fwrite(&numTris, sizeof(uint32), 1, output); fwrite("INDX", 4, 1, output); wsize = sizeof(uint32) + sizeof(unsigned short) * numTris; fwrite(&wsize, sizeof(int), 1, output); fwrite(&numTris, sizeof(uint32), 1, output); uint16* indices = new uint16[numTris]; if (numTris > 0) { uint32 i = 0; for (std::vector<Triangle<uint16> >::iterator itr2 = model.Triangles.begin(); itr2 != model.Triangles.end(); ++itr2, ++i) { indices[i * 3 + 0] = itr2->V0; indices[i * 3 + 1] = itr2->V1; indices[i * 3 + 2] = itr2->V2; } fwrite(indices, sizeof(uint16), numTris, output); } fwrite("VERT", 4, 1, output); wsize = sizeof(int) + sizeof(float) * 3 * numVerts; fwrite(&wsize, sizeof(int), 1, output); fwrite(&numVerts, sizeof(int), 1, output); float* vertices = new float[numVerts*3]; if (numVerts > 0) { uint32 i = 0; for (std::vector<Vector3>::iterator itr2 = model.Vertices.begin(); itr2 != model.Vertices.end(); ++itr2, ++i) { vertices[i * 3 + 0] = itr2->x; vertices[i * 3 + 1] = itr2->y; vertices[i * 3 + 2] = itr2->z; } fwrite(vertices, sizeof(float), numVerts * 3, output); } fclose(output); delete[] indices; delete[] vertices; uint32 displayId = (*itr)->Values[0]; uint32 pathLength = fileName.size(); fwrite(&displayId, sizeof(uint32), 1, modelList); fwrite(&pathLength, sizeof(uint32), 1, modelList); fwrite(fileName.c_str(), sizeof(char), pathLength, modelList); } else if (extension == "wmo") { WorldModelRoot model(path); FILE* output = fopen((baseBuildingsPath + fileName).c_str(), "wb"); if (!output) { printf("Could not create file %s, please check that you have write permissions\n", (baseBuildingsPath + fileName).c_str()); continue; } fwrite(Constants::VMAPMagic, 1, 8, output); uint32 numVertices = 0; fwrite(&numVertices, sizeof(uint32), 1, output); // will be filled later fwrite(&model.Header.CountGroups, sizeof(uint32), 1, output); fwrite(&model.Header.WmoId, sizeof(uint32), 1, output); const char grp[] = { 'G' , 'R' , 'P', ' ' }; for (std::vector<WorldModelGroup>::iterator itr2 = model.Groups.begin(); itr2 != model.Groups.end(); ++itr2) { const WMOGroupHeader& header = itr2->Header; fwrite(&header.Flags, sizeof(uint32), 1, output); fwrite(&header.WmoId, sizeof(uint32), 1, output); fwrite(&header.BoundingBox[0], sizeof(uint32), 1, output); fwrite(&header.BoundingBox[1], sizeof(uint32), 1, output); uint32 LiquidFlags = itr2->HasLiquidData ? 1 : 0; fwrite(&LiquidFlags, sizeof(uint32), 1, output); fwrite(grp, sizeof(char), sizeof(grp), output); uint32 k = 0; uint32 mobaBatch = itr2->MOBALength / 12; uint32* MobaEx = new uint32[mobaBatch*4]; for(uint32 i = 8; i < itr2->MOBALength; i += 12) MobaEx[k++] = itr2->MOBA[i]; int mobaSizeGrp = mobaBatch * 4 + 4; fwrite(&mobaSizeGrp, 4, 1, output); fwrite(&mobaBatch, 4, 1, output); fwrite(MobaEx, 4, k, output); delete[] MobaEx; //@TODO: Finish this. } fclose(output); } } fclose(modelList); printf("GameObject models extraction finished!"); Constants::ToWoWCoords = false; }

/** Extract sub block number <code>n</code> from <code>problem</code>. * The constructor creates a representation of block number <code>n</code> * as described in <code>problem</code>. * The constructor will also connect the newly created block to a remote * object solver instance. * @param problem The problem from which the block is to be extracted. * @param n Index of the block to be extracted. * @param argc Argument for IloCplex constructor. * @param argv Argument for IloCplex constructor. * @param machines List of machines to which to connect. If the code is * compiled for the TCP/IP transport then the block will * be connected to <code>machines[n]</code>. */ BendersOpt::Block::Block(Problem const *problem, IloInt n, int argc, char const *const *argv, std::vector<char const *> const &machines) : env(), number(n), vars(0), rows(0), cplex(0), cb(0) { IloNumVarArray problemVars = problem->getVariables(); IloRangeArray problemRanges = problem->getRows(); // Create a map that maps variables in the original model to their // respective index in problemVars. std::map<IloNumVar,IloInt,ExtractableLess<IloNumVar> > origIdxMap; for (IloInt j = 0; j < problemVars.getSize(); ++j) origIdxMap.insert(std::map<IloNumVar,IloInt,ExtractableLess<IloNumVar> >::value_type(problemVars[j], j)); // Copy non-fixed variables from original problem into primal problem. IloExpr primalObj(env); IloNumVarArray primalVars(env); IloRangeArray primalRows(env); IdxMap idxMap; // Index of original variable in block's primal model RowSet rowSet; for (IloInt j = 0; j < problemVars.getSize(); ++j) { IloNumVar x = problemVars[j]; if ( problem->getBlock(x) == number ) { // Create column in block LP with exactly the same data. if ( x.getType() != IloNumVar::Float ) { std::stringstream s; s << "Cannot create non-continuous block variable " << x; std::cerr << s.str() << std::endl; throw s.str(); } IloNumVar v(env, x.getLB(), x.getUB(), x.getType(), x.getName()); // Normalize objective function to 'minimize' double coef = problem->getObjCoef(x); if ( problem->getObjSense() != IloObjective::Minimize ) coef *= -1.0; primalObj += coef * v; // Record the index that the copied variable has in the // block model. idxMap.insert(IdxMap::value_type(x, primalVars.getSize())); primalVars.add(v); // Mark the rows that are intersected by this column // so that we can collect them later. RowSet const &intersected = problem->getIntersectedRows(x); for (RowSet::const_iterator it = intersected.begin(); it != intersected.end(); ++it) rowSet.insert(*it); } else idxMap.insert(IdxMap::value_type(x, -1)); } // Now copy all rows that intersect block variables. for (IloInt i = 0; i < problemRanges.getSize(); ++i) { IloRange r = problemRanges[i]; if ( rowSet.find(r) == rowSet.end() ) continue; // Create a copy of the row, normalizing it to '<=' double factor = 1.0; if ( r.getLB() > -IloInfinity ) factor = -1.0; IloRange primalR(env, factor < 0 ? -r.getUB() : r.getLB(), factor < 0 ? -r.getLB() : r.getUB(), r.getName()); IloExpr lhs(env); for (IloExpr::LinearIterator it = r.getLinearIterator(); it.ok(); ++it) { IloNumVar v = it.getVar(); double const val = factor * it.getCoef(); if ( problem->getBlock(v) != number ) { // This column is not explicitly in this block. This means // that it is a column that will be fixed by the master. // We collect all such columns so that we can adjust the // dual objective function according to concrete fixings. // Store information about variables in this block that // will be fixed by master solves. fixed.push_back(FixData(primalRows.getSize(), origIdxMap[v], -val)); } else { // The column is an ordinary in this block. Just copy it. lhs += primalVars[idxMap[v]] * val; } } primalR.setExpr(lhs); primalRows.add(primalR); lhs.end(); } // Create the dual of the primal model we just created. // Note that makeDual _always_ returns a 'maximize' objective. IloObjective objective(env, primalObj, IloObjective::Minimize); makeDual(objective, primalVars, primalRows, &obj, &vars, &rows); objective.end(); primalRows.endElements(); primalRows.end(); primalVars.endElements(); primalVars.end(); primalObj.end(); // Create a model. IloModel model(env); model.add(obj); model.add(vars); model.add(rows); for (IloExpr::LinearIterator it = obj.getLinearIterator(); it.ok(); ++it) objMap.insert(ObjMap::value_type(it.getVar(), it.getCoef())); // Finally create the IloCplex instance that will solve // the problems associated with this block. char const **transargv = new char const *[argc + 3]; for (int i = 0; i < argc; ++i) transargv[i] = argv[i]; #if defined(USE_MPI) char extra[128]; sprintf (extra, "-remoterank=%d", static_cast<int>(number + 1)); transargv[argc++] = extra; (void)machines; #elif defined(USE_PROCESS) char extra[128]; sprintf (extra, "-logfile=block%04d.log", static_cast<int>(number)); transargv[argc++] = extra; (void)machines; #elif defined(USE_TCPIP) transargv[argc++] = machines[number]; #endif cplex = IloCplex(model, TRANSPORT, argc, transargv); delete[] transargv; // Suppress output from this block's solver. cplex.setOut(env.getNullStream()); cplex.setWarning(env.getNullStream()); }

QModelIndex ProposalTreeWidget::indexFromRow(int r) const { return model()->index(r, 0); }

void BBTrackContainerView::addAutomationTrack() { (void) Track::create( Track::AutomationTrack, model() ); }

MSStringEntryField::MSStringEntryField(MSWidget *owner_,MSString& model_,const char *label_,const MSSymbol& tag_): MSEntryFieldPlus(owner_,label_,tag_) { model(model_); }

int main (int argc, char **argv) { int result = 0; IloEnv env; try { static int indices[] = { 0, 1, 2, 3, 4, 5, 6 }; IloModel model(env); /* ***************************************************************** * * * * S E T U P P R O B L E M * * * * The model we setup here is * * Minimize * * obj: 3x1 - x2 + 3x3 + 2x4 + x5 + 2x6 + 4x7 * * Subject To * * c1: x1 + x2 = 4 * * c2: x1 + x3 >= 3 * * c3: x6 + x7 <= 5 * * c4: -x1 + x7 >= -2 * * q1: [ -x1^2 + x2^2 ] <= 0 * * q2: [ 4.25x3^2 -2x3*x4 + 4.25x4^2 - 2x4*x5 + 4x5^2 ] + 2 x1 <= 9.0 * q3: [ x6^2 - x7^2 ] >= 4 * * Bounds * * 0 <= x1 <= 3 * * x2 Free * * 0 <= x3 <= 0.5 * * x4 Free * * x5 Free * * x7 Free * * End * * * * ***************************************************************** */ IloNumVarArray x(env); x.add(IloNumVar(env, 0, 3, "x1")); x.add(IloNumVar(env, -IloInfinity, IloInfinity, "x2")); x.add(IloNumVar(env, 0, 0.5, "x3")); x.add(IloNumVar(env, -IloInfinity, IloInfinity, "x4")); x.add(IloNumVar(env, -IloInfinity, IloInfinity, "x5")); x.add(IloNumVar(env, 0, IloInfinity, "x6")); x.add(IloNumVar(env, -IloInfinity, IloInfinity, "x7")); for (IloInt i = 0; i < x.getSize(); ++i) x[i].setObject(&indices[i]); IloObjective obj = IloMinimize(env, 3*x[0] - x[1] + 3*x[2] + 2*x[3] + x[4] + 2*x[5] + 4*x[6], "obj"); model.add(obj); IloRangeArray linear(env); linear.add(IloRange(env, 4.0, x[0] + x[1], 4.0, "c1")); linear.add(IloRange(env, 3.0, x[0] + x[2], IloInfinity, "c2")); linear.add(IloRange(env, -IloInfinity, x[5] + x[6], 5.0, "c3")); linear.add(IloRange(env, -2.0, -x[0] + x[6], IloInfinity, "c4")); for (IloInt i = 0; i < linear.getSize(); ++i) linear[i].setObject(&indices[i]); model.add(linear); IloRangeArray quad(env); quad.add(IloRange(env, -IloInfinity, -x[0]*x[0] + x[1] * x[1], 0, "q1")); quad.add(IloRange(env, -IloInfinity, 4.25*x[2]*x[2] - 2*x[2]*x[3] + 4.25*x[3]*x[3] + -2*x[3]*x[4] + 4*x[4]*x[4] + 2*x[0], 9.0, "q2")); quad.add(IloRange(env, 4.0, x[5]*x[5] - x[6]*x[6], IloInfinity, "q3")); for (IloInt i = 0; i < quad.getSize(); ++i) quad[i].setObject(&indices[i]); model.add(quad); /* ***************************************************************** * * * * O P T I M I Z E P R O B L E M * * * * ***************************************************************** */ IloCplex cplex(model); cplex.setParam(IloCplex::Param::Barrier::QCPConvergeTol, 1e-10); cplex.solve(); /* ***************************************************************** * * * * Q U E R Y S O L U T I O N * * * * ***************************************************************** */ IloNumArray xval(env); IloNumArray slack(env); IloNumArray qslack(env); IloNumArray cpi(env); IloNumArray rpi(env); IloNumArray qpi; cplex.getValues(x, xval); cplex.getSlacks(slack, linear); cplex.getSlacks(qslack, quad); cplex.getReducedCosts(cpi, x); cplex.getDuals(rpi, linear); qpi = getqconstrmultipliers(cplex, xval, quad); /* ***************************************************************** * * * * C H E C K K K T C O N D I T I O N S * * * * Here we verify that the optimal solution computed by CPLEX * * (and the qpi[] values computed above) satisfy the KKT * * conditions. * * * * ***************************************************************** */ // Primal feasibility: This example is about duals so we skip this test. // Dual feasibility: We must verify // - for <= constraints (linear or quadratic) the dual // multiplier is non-positive. // - for >= constraints (linear or quadratic) the dual // multiplier is non-negative. for (IloInt i = 0; i < linear.getSize(); ++i) { if ( linear[i].getLB() <= -IloInfinity ) { // <= constraint if ( rpi[i] > ZEROTOL ) { cerr << "Dual feasibility test failed for <= row " << i << ": " << rpi[i] << endl; result = -1; } } else if ( linear[i].getUB() >= IloInfinity ) { // >= constraint if ( rpi[i] < -ZEROTOL ) { cerr << "Dual feasibility test failed for >= row " << i << ":" << rpi[i] << endl; result = -1; } } else { // nothing to do for equality constraints } } for (IloInt q = 0; q < quad.getSize(); ++q) { if ( quad[q].getLB() <= -IloInfinity ) { // <= constraint if ( qpi[q] > ZEROTOL ) { cerr << "Dual feasibility test failed for <= quad " << q << ": " << qpi[q] << endl; result = -1; } } else if ( quad[q].getUB() >= IloInfinity ) { // >= constraint if ( qpi[q] < -ZEROTOL ) { cerr << "Dual feasibility test failed for >= quad " << q << ":" << qpi[q] << endl; result = -1; } } else { // nothing to do for equality constraints } } // Complementary slackness. // For any constraint the product of primal slack and dual multiplier // must be 0. for (IloInt i = 0; i < linear.getSize(); ++i) { if ( fabs (linear[i].getUB() - linear[i].getLB()) > ZEROTOL && fabs (slack[i] * rpi[i]) > ZEROTOL ) { cerr << "Complementary slackness test failed for row " << i << ": " << fabs (slack[i] * rpi[i]) << endl; result = -1; } } for (IloInt q = 0; q < quad.getSize(); ++q) { if ( fabs (quad[q].getUB() - quad[q].getLB()) > ZEROTOL && fabs (qslack[q] * qpi[q]) > ZEROTOL ) { cerr << "Complementary slackness test failed for quad " << q << ":" << fabs (qslack[q] * qpi[q]) << endl; result = -1; } } for (IloInt j = 0; j < x.getSize(); ++j) { if ( x[j].getUB() < IloInfinity ) { double const slk = x[j].getUB() - xval[j]; double const dual = cpi[j] < -ZEROTOL ? cpi[j] : 0.0; if ( fabs (slk * dual) > ZEROTOL ) { cerr << "Complementary slackness test failed for ub " << j << ": " << fabs (slk * dual) << endl; result = -1; } } if ( x[j].getLB() > -IloInfinity ) { double const slk = xval[j] - x[j].getLB(); double const dual = cpi[j] > ZEROTOL ? cpi[j] : 0.0; if ( fabs (slk * dual) > ZEROTOL ) { cerr << "Complementary slackness test failed for lb " << j << ": " << fabs (slk * dual) << endl; result = -1; } } } // Stationarity. // The difference between objective function and gradient at optimal // solution multiplied by dual multipliers must be 0, i.e., for the // optimal solution x // 0 == c // - sum(r in rows) r'(x)*rpi[r] // - sum(q in quads) q'(x)*qpi[q] // - sum(c in cols) b'(x)*cpi[c] // where r' and q' are the derivatives of a row or quadratic constraint, // x is the optimal solution and rpi[r] and qpi[q] are the dual // multipliers for row r and quadratic constraint q. // b' is the derivative of a bound constraint and cpi[c] the dual bound // multiplier for column c. IloNumArray kktsum(env, x.getSize()); // Objective function. for (IloExpr::LinearIterator it = obj.getLinearIterator(); it.ok(); ++it) kktsum[idx(it.getVar())] = it.getCoef(); // Linear constraints. // The derivative of a linear constraint ax - b (<)= 0 is just a. for (IloInt i = 0; i < linear.getSize(); ++i) { for (IloExpr::LinearIterator it = linear[i].getLinearIterator(); it.ok(); ++it) kktsum[idx(it.getVar())] -= rpi[i] * it.getCoef(); } // Quadratic constraints. // The derivative of a constraint xQx + ax - b <= 0 is // Qx + Q'x + a. for (IloInt q = 0; q < quad.getSize(); ++q) { for (IloExpr::LinearIterator it = quad[q].getLinearIterator(); it.ok(); ++it) kktsum[idx(it.getVar())] -= qpi[q] * it.getCoef(); for (IloExpr::QuadIterator it = quad[q].getQuadIterator(); it.ok(); ++it) { kktsum[idx(it.getVar1())] -= qpi[q] * xval[idx(it.getVar2())] * it.getCoef(); kktsum[idx(it.getVar2())] -= qpi[q] * xval[idx(it.getVar1())] * it.getCoef(); } } // Bounds. // The derivative for lower bounds is -1 and that for upper bounds // is 1. // CPLEX already returns dj with the appropriate sign so there is // no need to distinguish between different bound types here. for (IloInt j = 0; j < x.getSize(); ++j) kktsum[j] -= cpi[j]; for (IloInt j = 0; j < kktsum.getSize(); ++j) { if ( fabs (kktsum[j]) > ZEROTOL ) { cerr << "Stationarity test failed at index " << j << ": " << kktsum[j] << endl; result = -1; } } if ( result == 0) { // KKT conditions satisfied. Dump out the optimal solutions and // the dual values. streamsize oprec = cout.precision(3); ios_base::fmtflags oflags = cout.setf(ios::fixed | ios::showpos); cout << "Optimal solution satisfies KKT conditions." << endl; cout << " x[] = " << xval << endl; cout << " cpi[] = " << cpi << endl; cout << " rpi[] = " << rpi << endl; cout << " qpi[] = " << qpi << endl; cout.precision(oprec); cout.flags(oflags); } } catch (IloException& e) { cerr << "Concert exception caught: " << e << endl; result = -1; } catch (...) { cerr << "Unknown exception caught" << endl; result = -1; } env.end(); return result; } // END main

void InstrumentTrackView::activityIndicatorReleased() { model()->processInEvent( MidiEvent( MidiNoteOff, 0, DefaultKey, 0 ) ); }

TEST(McmcHmcIntegratorsImplLeapfrog, unit_e_symplecticness) { rng_t base_rng(0); std::fstream data_stream(std::string("").c_str(), std::fstream::in); stan::io::dump data_var_context(data_stream); data_stream.close(); std::stringstream model_output; std::stringstream metric_output; stan::interface_callbacks::writer::stream_writer writer(metric_output); std::stringstream error_stream; stan::interface_callbacks::writer::stream_writer error_writer(error_stream); gauss_model_namespace::gauss_model model(data_var_context, &model_output); stan::mcmc::impl_leapfrog< stan::mcmc::unit_e_metric<gauss_model_namespace::gauss_model, rng_t> > integrator; stan::mcmc::unit_e_metric<gauss_model_namespace::gauss_model, rng_t> metric(model); // Create a circle of points const int n_points = 1000; double pi = 3.141592653589793; double r = 1.5; double q0 = 1; double p0 = 0; std::vector<stan::mcmc::unit_e_point> z; for (int i = 0; i < n_points; ++i) { z.push_back(stan::mcmc::unit_e_point(1)); double theta = 2 * pi * (double)i / (double)n_points; z.back().q(0) = r * cos(theta) + q0; z.back().p(0) = r * sin(theta) + p0; } // Evolve circle double epsilon = 1e-3; size_t L = pi / epsilon; for (int i = 0; i < n_points; ++i) metric.init(z.at(i), writer, error_writer); for (size_t n = 0; n < L; ++n) for (int i = 0; i < n_points; ++i) integrator.evolve(z.at(i), metric, epsilon, writer, error_writer); // Compute area of evolved shape using divergence theorem in 2D double area = 0; for (int i = 0; i < n_points; ++i) { double x1 = z[i].q(0); double y1 = z[i].p(0); double x2 = z[(i + 1) % n_points].q(0); double y2 = z[(i + 1) % n_points].p(0); double x_bary = 0.5 * (x1 + x2); double y_bary = 0.5 * (y1 + y2); double x_delta = x2 - x1; double y_delta = y2 - y1; double a = sqrt( x_delta * x_delta + y_delta * y_delta); double x_norm = 1; double y_norm = - x_delta / y_delta; double norm = sqrt( x_norm * x_norm + y_norm * y_norm ); a *= (x_bary * x_norm + y_bary * y_norm) / norm; a = a < 0 ? -a : a; area += a; } area *= 0.5; // Symplectic integrators preserve volume (area in 2D) EXPECT_NEAR(area, pi * r * r, 1e-2); EXPECT_EQ("", model_output.str()); EXPECT_EQ("", metric_output.str()); }

void InstrumentTrackView::midiConfigChanged() { m_midiInputAction->setChecked( model()->m_midiPort.isReadable() ); m_midiOutputAction->setChecked( model()->m_midiPort.isWritable() ); }

int main (void) { IloEnv env; try { IloModel model(env); IloCplex cplex(env); IloInt nbWhouses = 4; IloInt nbLoads = 31; IloInt w, l; IloNumVarArray capVars(env, nbWhouses, 0, 10, ILOINT); // Used capacities IloNumArray capLbs (env, nbWhouses, 2, 3, 5, 7); // Minimum usage level IloNumArray costs (env, nbWhouses, 1, 2, 4, 6); // Cost per warehouse // These variables represent the assigninment of a // load to a warehouse. IloNumVarArrayArray assignVars(env, nbWhouses); for (w = 0; w < nbWhouses; w++) { assignVars[w] = IloNumVarArray(env, nbLoads, 0, 1, ILOINT); // Links the number of loads assigned to a warehouse with // the capacity variable of the warehouse. model.add(IloSum(assignVars[w]) == capVars[w]); } // Each load must be assigned to just one warehouse. for (l = 0; l < nbLoads; l++) { IloNumVarArray aux(env); for (w = 0; w < nbWhouses; w++) aux.add(assignVars[w][l]); model.add(IloSum(aux) == 1); aux.end(); } model.add (IloMinimize(env, IloScalProd(costs, capVars))); cplex.extract(model); cplex.setParam(IloCplex::Param::MIP::Strategy::Search, IloCplex::Traditional); if ( cplex.solve(SemiContGoal(env, capVars, capLbs)) ) { cout << " --------------------------------------------------" << endl; cout << "Solution status: " << cplex.getStatus() << endl; cout << endl << "Solution found:" << endl; cout << " Objective value = " << cplex.getObjValue() << endl << endl; for (w = 0; w < nbWhouses; w++) { cout << "Warehouse " << w << ": stored " << cplex.getValue(capVars[w]) << " loads" << endl; for (l = 0; l < nbLoads; l++) { if ( cplex.getValue(assignVars[w][l]) > 1e-5 ) cout << "Load " << l << " | "; } cout << endl << endl; } cout << " --------------------------------------------------" << endl; } else { cout << " No solution found " << endl; } } catch (IloException& e) { cerr << "Concert exception caught: " << e << endl; } env.end(); return 0; } // END main

void EditTreeView::removeAll() { if (!model()) return; model()->removeRows(0, model()->rowCount(rootIndex()), rootIndex()); }

void ThreadsWindow::resizeColumnsToContents() { const int columnCount = model()->columnCount(); for (int c = 0 ; c < columnCount; c++) resizeColumnToContents(c); }

void PieView::paintEvent(QPaintEvent *event) { QItemSelectionModel *selections = selectionModel(); QStyleOptionViewItem option = viewOptions(); QStyle::State state = option.state; QBrush background = option.palette.base(); QPen foreground(option.palette.color(QPalette::WindowText)); QPen textPen(option.palette.color(QPalette::Text)); QPen highlightedPen(option.palette.color(QPalette::HighlightedText)); QPainter painter(viewport()); painter.setRenderHint(QPainter::Antialiasing); painter.fillRect(event->rect(), background); painter.setPen(foreground); // Viewport rectangles QRect pieRect = QRect(margin, margin, pieSize, pieSize); QPoint keyPoint = QPoint(totalSize - horizontalScrollBar()->value(), margin - verticalScrollBar()->value()); if (validItems > 0) { painter.save(); painter.translate(pieRect.x() - horizontalScrollBar()->value(), pieRect.y() - verticalScrollBar()->value()); painter.drawEllipse(0, 0, pieSize, pieSize); double startAngle = 0.0; int row; for (row = 0; row < model()->rowCount(rootIndex()); ++row) { QModelIndex index = model()->index(row, 1, rootIndex()); double value = model()->data(index).toDouble(); if (value > 0.0) { double angle = 360*value/totalValue; QModelIndex colorIndex = model()->index(row, 0, rootIndex()); QColor color = QColor(model()->data(colorIndex, Qt::DecorationRole).toString()); if (currentIndex() == index) painter.setBrush(QBrush(color, Qt::Dense4Pattern)); else if (selections->isSelected(index)) painter.setBrush(QBrush(color, Qt::Dense3Pattern)); else painter.setBrush(QBrush(color)); painter.drawPie(0, 0, pieSize, pieSize, int(startAngle*16), int(angle*16)); startAngle += angle; } } painter.restore(); int keyNumber = 0; for (row = 0; row < model()->rowCount(rootIndex()); ++row) { QModelIndex index = model()->index(row, 1, rootIndex()); double value = model()->data(index).toDouble(); if (value > 0.0) { QModelIndex labelIndex = model()->index(row, 0, rootIndex()); QStyleOptionViewItem option = viewOptions(); option.rect = visualRect(labelIndex); if (selections->isSelected(labelIndex)) option.state |= QStyle::State_Selected; if (currentIndex() == labelIndex) option.state |= QStyle::State_HasFocus; itemDelegate()->paint(&painter, option, labelIndex); keyNumber++; } } } }

void KateCompletionTree::resizeColumns(bool firstShow, bool forceResize) { static bool preventRecursion = false; if (preventRecursion) { return; } m_resizeTimer->stop(); if (firstShow) { forceResize = true; } preventRecursion = true; widget()->setUpdatesEnabled(false); int modelIndexOfName = kateModel()->translateColumn(KTextEditor::CodeCompletionModel::Name); int oldIndentWidth = columnViewportPosition(modelIndexOfName); ///Step 1: Compute the needed column-sizes for the visible content const int numColumns = model()->columnCount(); QVarLengthArray<int, 8> columnSize(numColumns); for (int i = 0; i < numColumns; ++i) { columnSize[i] = 5; } QModelIndex current = indexAt(QPoint(1, 1)); const bool changed = current.isValid(); int currentYPos = 0; measureColumnSizes(this, current, columnSize, currentYPos, height()); int totalColumnsWidth = 0, originalViewportWidth = viewport()->width(); int maxWidth = (QApplication::desktop()->screenGeometry(widget()->view()).width() * 3) / 4; ///Step 2: Update column-sizes //This contains several hacks to reduce the amount of resizing that happens. Generally, //resizes only happen if a) More than a specific amount of space is saved by the resize, or //b) the resizing is required so the list can show all of its contents. int minimumResize = 0; int maximumResize = 0; if (changed) { for (int n = 0; n < numColumns; n++) { totalColumnsWidth += columnSize[n]; int diff = columnSize[n] - columnWidth(n); if (diff < minimumResize) { minimumResize = diff; } if (diff > maximumResize) { maximumResize = diff; } } int noReduceTotalWidth = 0; //The total width of the widget of no columns are reduced for (int n = 0; n < numColumns; n++) { if (columnSize[n] < columnWidth(n)) { noReduceTotalWidth += columnWidth(n); } else { noReduceTotalWidth += columnSize[n]; } } //Check whether we can afford to reduce none of the columns //Only reduce size if we widget would else be too wide. bool noReduce = noReduceTotalWidth < maxWidth && !forceResize; if (noReduce) { totalColumnsWidth = 0; for (int n = 0; n < numColumns; n++) { if (columnSize[n] < columnWidth(n)) { columnSize[n] = columnWidth(n); } totalColumnsWidth += columnSize[n]; } } if (minimumResize > -40 && maximumResize == 0 && !forceResize) { //No column needs to be exanded, and no column needs to be reduced by more than 40 pixels. //To prevent flashing, do not resize at all. totalColumnsWidth = 0; for (int n = 0; n < numColumns; n++) { columnSize[n] = columnWidth(n); totalColumnsWidth += columnSize[n]; } } else { // viewport()->resize( 5000, viewport()->height() ); for (int n = 0; n < numColumns; n++) { setColumnWidth(n, columnSize[n]); } // qCDebug(LOG_KTE) << "resizing viewport to" << totalColumnsWidth; viewport()->resize(totalColumnsWidth, viewport()->height()); } } ///Step 3: Update widget-size and -position int scrollBarWidth = verticalScrollBar()->width(); int newIndentWidth = columnViewportPosition(modelIndexOfName); int newWidth = qMin(maxWidth, qMax(75, totalColumnsWidth)); if (newWidth == maxWidth) { setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded); } else { setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); } if (maximumResize > 0 || forceResize || oldIndentWidth != newIndentWidth) { // qCDebug(LOG_KTE) << geometry() << "newWidth" << newWidth << "current width" << width() << "target width" << newWidth + scrollBarWidth; if ((newWidth + scrollBarWidth) != width() && originalViewportWidth != totalColumnsWidth) { widget()->resize(newWidth + scrollBarWidth + 2, widget()->height()); resize(newWidth + scrollBarWidth, widget()->height() - (2 * widget()->frameWidth())); } // qCDebug(LOG_KTE) << "created geometry:" << widget()->geometry() << geometry() << "newWidth" << newWidth << "viewport" << viewport()->width(); if (viewport()->width() > totalColumnsWidth) { //Set the size of the last column to fill the whole rest of the widget setColumnWidth(numColumns - 1, viewport()->width() - columnViewportPosition(numColumns - 1)); } /* for(int a = 0; a < numColumns; ++a) qCDebug(LOG_KTE) << "column" << a << columnWidth(a) << "target:" << columnSize[a];*/ if (oldIndentWidth != newIndentWidth) if (widget()->updatePosition() && !forceResize) { preventRecursion = false; resizeColumns(true, true); } } widget()->setUpdatesEnabled(true); preventRecursion = false; }

int PieView::rows(const QModelIndex &index) const { return model()->rowCount(model()->parent(index)); }

QPixmap KFileItemListView::createDragPixmap(const KItemSet& indexes) const { if (!model()) { return QPixmap(); } const int itemCount = indexes.count(); Q_ASSERT(itemCount > 0); if (itemCount == 1) { return KItemListView::createDragPixmap(indexes); } // If more than one item is dragged, align the items inside a // rectangular grid. The maximum grid size is limited to 5 x 5 items. int xCount; int size; if (itemCount > 16) { xCount = 5; size = KIconLoader::SizeSmall; } else if (itemCount > 9) { xCount = 4; size = KIconLoader::SizeSmallMedium; } else { xCount = 3; size = KIconLoader::SizeMedium; } if (itemCount < xCount) { xCount = itemCount; } int yCount = itemCount / xCount; if (itemCount % xCount != 0) { ++yCount; } if (yCount > xCount) { yCount = xCount; } const qreal dpr = scene()->views()[0]->devicePixelRatio(); // Draw the selected items into the grid cells. QPixmap dragPixmap(QSize(xCount * size + xCount, yCount * size + yCount) * dpr); dragPixmap.setDevicePixelRatio(dpr); dragPixmap.fill(Qt::transparent); QPainter painter(&dragPixmap); int x = 0; int y = 0; foreach (int index, indexes) { QPixmap pixmap = model()->data(index).value("iconPixmap").value<QPixmap>(); if (pixmap.isNull()) { QIcon icon = QIcon::fromTheme(model()->data(index).value("iconName").toString()); pixmap = icon.pixmap(size, size); } else { KPixmapModifier::scale(pixmap, QSize(size, size) * dpr); } painter.drawPixmap(x, y, pixmap); x += size + 1; if (x >= dragPixmap.width()) { x = 0; y += size + 1; } if (y >= dragPixmap.height()) { break; } }

QModelIndex PieView::indexAt(const QPoint &point) const { if (validItems == 0) return QModelIndex(); // Transform the view coordinates into contents widget coordinates. int wx = point.x() + horizontalScrollBar()->value(); int wy = point.y() + verticalScrollBar()->value(); if (wx < totalSize) { double cx = wx - totalSize/2; double cy = totalSize/2 - wy; // positive cy for items above the center // Determine the distance from the center point of the pie chart. double d = pow(pow(cx, 2) + pow(cy, 2), 0.5); if (d == 0 || d > pieSize/2) return QModelIndex(); // Determine the angle of the point. double angle = (180 / M_PI) * acos(cx/d); if (cy < 0) angle = 360 - angle; // Find the relevant slice of the pie. double startAngle = 0.0; for (int row = 0; row < model()->rowCount(rootIndex()); ++row) { QModelIndex index = model()->index(row, 1, rootIndex()); double value = model()->data(index).toDouble(); if (value > 0.0) { double sliceAngle = 360*value/totalValue; if (angle >= startAngle && angle < (startAngle + sliceAngle)) return model()->index(row, 1, rootIndex()); startAngle += sliceAngle; } } } else { double itemHeight = QFontMetrics(viewOptions().font).height(); int listItem = int((wy - margin) / itemHeight); int validRow = 0; for (int row = 0; row < model()->rowCount(rootIndex()); ++row) { QModelIndex index = model()->index(row, 1, rootIndex()); if (model()->data(index).toDouble() > 0.0) { if (listItem == validRow) return model()->index(row, 0, rootIndex()); // Update the list index that corresponds to the next valid row. validRow++; } } } return QModelIndex(); }

QVariant QgsSymbolV2LegendNode::data( int role ) const { if ( role == Qt::DisplayRole ) { return mLabel; } else if ( role == Qt::EditRole ) { return mUserLabel.isEmpty() ? mItem.label() : mUserLabel; } else if ( role == Qt::DecorationRole ) { if ( mPixmap.isNull() || mPixmap.size() != mIconSize ) { QPixmap pix; if ( mItem.symbol() ) { QScopedPointer<QgsRenderContext> context( createTemporaryRenderContext() ); pix = QgsSymbolLayerV2Utils::symbolPreviewPixmap( mItem.symbol(), mIconSize, context.data() ); } else { pix = QPixmap( mIconSize ); pix.fill( Qt::transparent ); } if ( mItem.level() == 0 || ( model() && model()->testFlag( QgsLayerTreeModel::ShowLegendAsTree ) ) ) mPixmap = pix; else { // ident the symbol icon to make it look like a tree structure QPixmap pix2( pix.width() + mItem.level() * indentSize, pix.height() ); pix2.fill( Qt::transparent ); QPainter p( &pix2 ); p.drawPixmap( mItem.level() * indentSize, 0, pix ); p.end(); mPixmap = pix2; } } return mPixmap; } else if ( role == Qt::CheckStateRole ) { if ( !mItem.isCheckable() ) return QVariant(); QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer*>( mLayerNode->layer() ); if ( !vlayer || !vlayer->rendererV2() ) return QVariant(); return vlayer->rendererV2()->legendSymbolItemChecked( mItem.ruleKey() ) ? Qt::Checked : Qt::Unchecked; } else if ( role == RuleKeyRole ) { return mItem.ruleKey(); } else if ( role == SymbolV2LegacyRuleKeyRole ) { return QVariant::fromValue<void*>( mItem.legacyRuleKey() ); } else if ( role == ParentRuleKeyRole ) { return mItem.parentRuleKey(); } return QVariant(); }

int KNNotificationView::heightHint() const { return (model()==nullptr || model()->rowCount()==0)? 45:model()->rowCount()*NotificationItemHeight; }

/** * The main entry of dw-lr-train, whose goal * is to takes as input in the same format as * libsvm, and train a classifier. **/ int main(int argc, char ** argv){ /** * First, parse command line input to get * (1) step size * (2) number of epoches to run * (3) regularization (l2) **/ std::string filename; int flags, opt; int nsecs, tfnd; nsecs = 0; tfnd = 0; flags = 0; while ((opt = getopt(argc, argv, "s:e:r:")) != -1) { switch (opt) { case 's': stepsize = atof(optarg); break; case 'e': epoches = atof(optarg); break; case 'r': lambda = atof(optarg); break; default: fprintf(stderr, "Usage: %s [-s stepsize] [-e epoches] [-r regularization] trainfile\n", argv[0]); exit(EXIT_FAILURE); } } if (optind >= argc) { fprintf(stderr, "Expected argument after options\n"); exit(EXIT_FAILURE); } filename = std::string(argv[optind]); printf("stepsize=%f; epoches=%f; lambda=%f\n", stepsize, epoches, lambda); printf("trainfile = %s\n", filename.c_str()); /** * Second, create corpus **/ size_t n_elements, n_examples, n_features; double * p_examples; long * p_cols; long * p_rows; get_corpus_stats(filename.c_str(), &n_elements, &n_examples); n_features = create_dw_corpus(filename.c_str(), n_elements, n_examples, p_examples, p_cols, p_rows); printf("#elements=%zu; #examples=%zu; #n_features=%zu\n", n_elements, n_examples, n_features); /** * Third, create DimmWitted object, and let it run. **/ GLMModelExample_Sparse model(n_features); for(int i=0;i<model.n;i++){ model.p[i] = 0.0; } SparseDimmWitted<double, GLMModelExample_Sparse, DW_MODELREPL_PERMACHINE, DW_DATAREPL_SHARDING, DW_ACCESS_ROW> dw(p_examples, p_rows, p_cols, n_examples, n_features+1, n_elements, &model); unsigned int f_handle_grad = dw.register_row(f_lr_grad_sparse); unsigned int f_handle_loss = dw.register_row(f_lr_loss_sparse); dw.register_model_avg(f_handle_grad, f_lr_modelavg); dw.register_model_avg(f_handle_loss, f_lr_modelavg); printf("Start training...\n"); double sum = 0.0; for(int i_epoch=0;i_epoch<epoches;i_epoch++){ double loss = dw.exec(f_handle_loss)/n_examples; std::cout << "loss=" << loss << std::endl; dw.exec(f_handle_grad); } /** * Forth, dump result. **/ printf("Dumping training result to %s.model...\n", filename.c_str()); std::ofstream fout((filename + ".model").c_str()); fout << n_features << std::endl; for(int i=0;i<model.n;i++){ fout << model.p[i] << std::endl; } fout.close(); exit(EXIT_SUCCESS); }

int main() { Leph::HumanoidFloatingModel model(Leph::SigmabanModel); model.putOnGround(); Leph::ModelViewer viewer(1200, 900); //Inverse Kinematics Leph::InverseKinematics inv(model); //Declare model degrees of freedom inv.addDOF("right_hip_pitch"); inv.addDOF("right_hip_roll"); inv.addDOF("right_knee"); inv.addDOF("right_ankle_pitch"); inv.addDOF("right_ankle_roll"); inv.addDOF("left_hip_pitch"); inv.addDOF("left_hip_roll"); inv.addDOF("left_knee"); inv.addDOF("left_ankle_pitch"); inv.addDOF("left_ankle_roll"); inv.addDOF("base_x"); inv.addDOF("base_y"); inv.addDOF("base_z"); //Declare degree of freefom box bounds //XXX Not fully implemented inv.setLowerBound("left_knee", 0.0); inv.setLowerBound("right_knee", 0.0); //Declare target position inv.addTargetPosition("flying_foot", "right_foot_tip"); inv.addTargetPosition("support_foot", "left_foot_tip"); //target of center of mass inv.addTargetCOM(); inv.targetCOM().z() -= 0.05; //Target orientation inv.addTargetOrientation("flying_foot", "right_foot_tip"); inv.addTargetOrientation("support_foot", "left_foot_tip"); Leph::Chrono chrono; double t = 0.0; while (viewer.update()) { t += 0.01; //Update targets inv.targetPosition("flying_foot").z() = 0.05+0.02*sin(t); inv.targetPosition("flying_foot").x() = 0.05+0.02*sin(2.0*t); inv.targetCOM().y() = 0.01*sin(t); inv.targetCOM().x() = 0.01*sin(2.0*t); chrono.start("InverseKinematics"); //Compute Inverse Kinematics inv.run(0.0001, 100); chrono.stop("InverseKinematics"); chrono.print(); std::cout << "ERRORS" << std::endl; std::cout << "COM pos: " << inv.errorCOM() << std::endl; std::cout << "Flying foot pos: " << inv.errorPosition("flying_foot") << std::endl; std::cout << "Support foot pos: " << inv.errorPosition("support_foot") << std::endl; std::cout << "Flying foot orientation: " << inv.errorOrientation("flying_foot") << std::endl; std::cout << "Support foot orientation: " << inv.errorOrientation("support_foot") << std::endl; //Display Eigen::Vector3d pt = model.centerOfMass("origin"); viewer.addTrackedPoint(pt); Leph::ModelDraw(model, viewer); } return 0; }