// 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)
{
Example #2
0
const QStandardItemModel *FlagsComboBox::standardItemModel() const
{
    return static_cast<const QStandardItemModel *>(model());
}
Example #3
0
/*! \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());
}
Example #6
0
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
//	);
}
Example #7
0
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;
}
Example #8
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()));
}
Example #9
0
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;
}
Example #11
0
/** 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());
}
Example #12
0
QModelIndex ProposalTreeWidget::indexFromRow(int r) const
{
	return model()->index(r, 0);
}
Example #13
0
void BBTrackContainerView::addAutomationTrack()
{
	(void) Track::create( Track::AutomationTrack, model() );
}
Example #14
0
MSStringEntryField::MSStringEntryField(MSWidget *owner_,MSString& model_,const char *label_,const MSSymbol& tag_):
MSEntryFieldPlus(owner_,label_,tag_) 
{ model(model_); }
Example #15
0
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
Example #16
0
void InstrumentTrackView::activityIndicatorReleased()
{
	model()->processInEvent( MidiEvent( MidiNoteOff, 0, DefaultKey, 0 ) );
}
Example #17
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());
}
Example #18
0
void InstrumentTrackView::midiConfigChanged()
{
	m_midiInputAction->setChecked( model()->m_midiPort.isReadable() );
	m_midiOutputAction->setChecked( model()->m_midiPort.isWritable() );
}
Example #19
0
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
Example #20
0
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);
}
Example #22
0
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;
}
Example #24
0
int PieView::rows(const QModelIndex &index) const
{
    return model()->rowCount(model()->parent(index));
}
Example #25
0
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;
        }
    }
Example #26
0
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();
}
Example #28
0
int KNNotificationView::heightHint() const
{
    return (model()==nullptr || model()->rowCount()==0)?
                45:model()->rowCount()*NotificationItemHeight;
}
Example #29
0
/**
 * 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;
}