void test_gemm(const std::string &name, int M, int N, int K, float alpha, float beta)
{
    Halide::Buffer<int32_t> sizes(3);
    Halide::Buffer<float> params(3);
    Halide::Buffer<float> A(K, M);
    Halide::Buffer<float> B(N, K);
    Halide::Buffer<float> C(N, M);
    Halide::Buffer<float> C_ref(N, M);
    sizes(0) = M;
    sizes(1) = N;
    sizes(2) = K;
    params(0) = alpha;
    params(1) = beta;
    for (int i = 0; i < K; i++)
        for (int j = 0; j < M; j++)
            A(i, j) = std::rand() % 10 - 5;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < K; j++)
            B(i, j) = std::rand() % 10 - 5;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++)
            C(i, j) = std::rand() % 10 - 5;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            C_ref(i, j) = beta * C(i, j);
            for (int k = 0; k < K; k++) {
                C_ref(i, j) += alpha * A(k, j) * B(i, k);
            }
        }
    }

    test_162(sizes.raw_buffer(), params.raw_buffer(),
             A.raw_buffer(), B.raw_buffer(), C.raw_buffer());
    compare_buffers(name, C, C_ref);
}

inline int Blob::xsize(int axis) const
{
    if (axis < -dims() || axis >= dims())
        return 1;

    return sizes()[(axis < 0) ? axis + dims() : axis];
}

Splitter::Splitter(QWidget *parent) : QWidget(parent) {
	QHBoxLayout *hbox = new QHBoxLayout(this);

	QFrame *topleft = new QFrame(this);
	topleft->setFrameShape(QFrame::StyledPanel);

	QFrame *topright = new QFrame(this);
	topright->setFrameShape(QFrame::StyledPanel);

	QSplitter *splitter1 = new QSplitter(Qt::Horizontal, this);
	splitter1->addWidget(topleft);
	splitter1->addWidget(topright);

	QFrame *bottom = new QFrame(this);
	bottom->setFrameShape(QFrame::StyledPanel);

	QSplitter *splitter2 = new QSplitter(Qt::Vertical, this);
	splitter2->addWidget(splitter1);
	splitter2->addWidget(bottom);

	QList<int> sizes({50, 100});
	splitter2->setSizes(sizes);

	hbox->addWidget(splitter2);
}

int
Splitter::getRightChildrenSize() const
{
    QList<int> list = sizes();
    assert(list.size() == 2);
    return list.back();
}

void sf_out(sf_file out        /* output file */, 
	    int axis           /* join axis */,
	    const char *iname  /* name of the input file */)
/*< prepare output >*/
{
    char *oname, cmdline[SF_CMDLEN];
    int ndim;
    off_t n[SF_MAX_DIM];
    sf_file inp;
    FILE *ofile=NULL;

    ofile = sf_tempfile(&oname,"w+b");
    fclose(ofile);

    snprintf(cmdline,SF_CMDLEN,"%s %s --dryrun=y < %s > %s",
	     command,splitcommand,iname,oname);
    sf_system(cmdline);
    
    inp = sf_input(oname);
    ndim = sf_largefiledims (inp,n);
    
    if (axis > ndim) axis=ndim;

    snprintf(nkey,5,"n%d",axis);
    axis--;
    sizes(inp,axis,ndim,n,&size1,&size2);
    
    sf_setformat(out,sf_histstring(inp,"data_format"));
    sf_fileflush(out,inp);
    
    sf_setform(out,SF_NATIVE);
    sf_rm(oname,true,false,false);
}

void Desktopwidget::closing (void)
   {
   QList<int> size = sizes ();

   setSettingsSizes ("desktopwidget/", size);
   _page->closing ();
   }

void AnimatedSplitter::setActiveWidgetWidth(int width)
{
	if (mActiveIndex >=0 && mActiveIndex < count()) {
		qDebug() << "w" << width;
		// We have to explicitly redistribute the sizes, otherwise
		// any additional/missing space is distributed amongst the widgets
		// according to the relative weight of the sizes. see. setSizes() documentation
		QList<int> sz(sizes());
		int delta = width - sz.at(mActiveIndex);  // < 0 for shrinking
		if (mActiveIndex < count()-1 && sz.at(mActiveIndex+1) > delta) {
			// take place from right
			sz.replace(mActiveIndex, width);
			sz.replace(mActiveIndex+1, sz.at(mActiveIndex+1) - delta);
		} else if (mActiveIndex > 0 && sz.at(mActiveIndex-1) > delta) {
			// take place from left
			sz.replace(mActiveIndex, width);
			sz.replace(mActiveIndex-1, sz.at(mActiveIndex-1) - delta);
		} else {
			// fallback:
			// TODO: the widget likely will not have the final width "width", because of space redistribution
			sz.replace(mActiveIndex, width);
			qDebug() << "AnimatedSplitter fallback: no cannot take space from adjacent widgets";
		}
		setSizes(sz);
	}
}

void BarChartWidget::drawBars(QPainter &painter) {
    std::vector<int> sizes(BAR_COUNT, 0);
    fillSizes(sizes);

    QRect baseRectangle = rect();
    int activeWidth = (int) std::floor( baseRectangle.width() * (1 - 2 * PADDING) );
    int singleBarWidth = (int) std::floor((activeWidth - (BAR_COUNT + 1) * SPACING) / BAR_COUNT);

    int baseLineY = (int) std::floor(baseRectangle.bottom() - PADDING_BOTTOM);
    int currX = (int) std::floor(baseRectangle.left() + baseRectangle.width() * PADDING);

    currX += SPACING;
    for (int i = 0; i < BAR_COUNT; i++) {
        QPoint pointTopLeft(currX, baseLineY - sizes.at((unsigned long) i));
        QPoint pointBottomRight(currX + singleBarWidth, baseLineY - 1);
        QRect bar(pointTopLeft, pointBottomRight);
        painter.setPen(mainColor);
        painter.drawRect(bar);
        painter.fillRect(bar, barColor);

        QPoint textTopLeft(currX, baseLineY);
        QPoint textBottomRight(currX + singleBarWidth, baseRectangle.bottom());
        QRect textRect(textTopLeft, textBottomRight);
        painter.setPen(mainColor);
        painter.drawText(textRect, Qt::AlignCenter, labels->at((unsigned long) i));
        
        QPoint valueTopLeft(currX, baseLineY - sizes.at((unsigned long) i) - VALUE_LABEL_HEIGHT);
        QPoint valueBottomRight(currX + singleBarWidth, baseLineY);
        QRect valueLabelRect(valueTopLeft, valueBottomRight);
        QString textValue = QString::number(values->at((unsigned long) i));
        painter.drawText(valueLabelRect, Qt::AlignHCenter | Qt::AlignTop, textValue);
        
        currX += singleBarWidth + SPACING;
    }
}

std::array<uint64_t, 3> nrrd_impl::dimensions() {
  std::istringstream sizes(this->value("sizes"));
  std::array<uint64_t, 3> dims;

  sizes >> dims[0] >> dims[1] >> dims[2];
  return dims;
}

int main(int argc,char* argv[]){
    // Create some type shortcuts
    typedef Optizelle::Rm <double> X;
    typedef Optizelle::SQL <double> Z;
    typedef X::Vector X_Vector;
    typedef Z::Vector Z_Vector;

    // Read in the name for the input file
    if(argc!=2) {
        std::cerr << "simple_quadratic_cone <parameters>" << std::endl;
        exit(EXIT_FAILURE);
    }
    std::string fname(argv[1]);

    // Generate an initial guess for the primal
    X_Vector x(2);
    x[0]=1.2; x[1]=3.1;

    // Generate an initial guess for the dual
    std::vector <Optizelle::Natural> sizes(1);
        sizes[0]=2;
    std::vector <Optizelle::Cone::t> types(1);
        types[0]=Optizelle::Cone::Quadratic;
    Z_Vector z(types,sizes);

    // Create an optimization state
    Optizelle::InequalityConstrained <double,Optizelle::Rm,Optizelle::SQL>
        ::State::t state(x,z);

    // Read the parameters from file
    Optizelle::json::InequalityConstrained <double,Optizelle::Rm,Optizelle::SQL>
        ::read(Optizelle::Messaging(),fname,state);
    
    // Create a bundle of functions
    Optizelle::InequalityConstrained<double,Optizelle::Rm,Optizelle::SQL>
        ::Functions::t fns;
    fns.f.reset(new MyObj);
    fns.h.reset(new MyIneq);

    // Solve the optimization problem
    Optizelle::InequalityConstrained <double,Optizelle::Rm,Optizelle::SQL>
        ::Algorithms::getMin(Optizelle::Messaging(),fns,state);

    // Print out the reason for convergence
    std::cout << "The algorithm converged due to: " <<
        Optizelle::StoppingCondition::to_string(state.opt_stop) << std::endl;

    // Print out the final answer
    std::cout << std::setprecision(16) << std::scientific 
        << "The optimal point is: (" << state.x[0] << ','
	<< state.x[1] << ')' << std::endl;

    // Write out the final answer to file
    Optizelle::json::InequalityConstrained <double,Optizelle::Rm,Optizelle::SQL>
        ::write_restart(Optizelle::Messaging(),"solution.json",state);

    // Successful termination
    return EXIT_SUCCESS;
}

// Unsqueezes src `before` times at the front and `after` times at the end
static Tensor unsqueezeN(const Tensor & src, int64_t before, int64_t after) {
  auto srcSizes = src.sizes();
  auto nDim = src.dim();
  std::vector<int64_t> sizes(nDim + before + after, 1);
  for (int64_t i = 0; i < nDim; i++) {
    sizes[i + before] = srcSizes[i];
  }
  return src.view(sizes);
}

/**
 * Returns number of synapses formed.
 * Fills it in transpose form, because we need to count and index the 
 * number of synapses on the target, so we need to iterate over the sources
 * in the inner loop. Once full, does the transpose.
 * Should really have a seed argument for the random number.
 * Later need a way to fast-forward mtrand to just the entries we
 * need to fill.
 */
unsigned int SparseMsg::randomConnect( double probability )
{
	unsigned int nRows = matrix_.nRows(); // Sources
	unsigned int nCols = matrix_.nColumns();	// Destinations
	matrix_.clear();
	unsigned int totalSynapses = 0;
	vector< unsigned int > sizes( nCols, 0 );
	unsigned int totSynNum = 0;
	Element* syn = e2_;
	unsigned int startData = syn->localDataStart();
	unsigned int endData = startData + syn->numLocalData();

	assert( nCols == syn->numData() );

	matrix_.transpose();
	for ( unsigned int i = 0; i < nCols; ++i ) {
		vector< unsigned int > synIndex;
		// This needs to be obtained from current size of syn array.
		// unsigned int synNum = sizes[ i ];
		unsigned int synNum = 0;
		for ( unsigned int j = 0; j < nRows; ++j ) {
			double r = mtrand(); // Want to ensure it is called each time round the loop.
			if ( r < probability ) {
				synIndex.push_back( synNum );
				++synNum;
				++totSynNum;
			} else {
				synIndex.push_back( ~0 );
			}
		}
			
		if ( i >= startData && i < endData ) {
			e2_->resizeField( i - startData, synNum );
		}
			totalSynapses += synNum;
			matrix_.addRow( i, synIndex );
		/*
		 * This is the correct form, but I need to implement something
		 * to check up for target nodes in order to use this.
		if ( i >= startData && i < endData ) {
			e2_->resizeField( i - startData, synNum );
			totalSynapses += synNum;
			matrix_.addRow( i, synIndex );
		} else {
			synIndex.resize( 0 );
			synIndex.assign( nRows, ~0 );
			matrix_.addRow( i, synIndex );
		}
		*/
	}

	matrix_.transpose();
	// cout << Shell::myNode() << ": sizes.size() = " << sizes.size() << ", ncols = " << nCols << ", startSynapse = " << startSynapse << endl;
	e1()->markRewired();
	e2()->markRewired();
	return totalSynapses;
}

 bool Kernel::NDRange::divisible (NDRange& range) const {
     if (range.dims() != dims())
         return false;
         
     for (int i = 0; i < dims(); i++)
         if (sizes()[i] % range.sizes()[i] != 0)
             return false;
             
     return true;
 }

int main()
{
	sizes();

	{
		A* pB = new B;
		delete pB;
	}
	std::cin.get();
	return 0;
}

int main()
{
  char ch = 'a';
  int i = 100;
  int* p;
  *p = 10;
  bool b = true;
  double d = 10.0;

  sizes(ch, i, p, b, d);
}

QString
Splitter::serializeNatron() const
{
    QMutexLocker l(&_lock);

    QList<int> list = sizes();
    if (list.size() == 2) {
        return QString::fromUtf8("%1 %2").arg(list[0]).arg(list[1]);
    }

    return QString();
}

  void InlineCacheRegistry::print_stats(STATE) {
    SYNC(state);
    int total = 0;
    std::vector<int> sizes(cTrackedICHits + 1);

    int overflow = 0;

    for(CacheHash::iterator hi = caches_.begin();
        hi != caches_.end();
        ++hi) {
      for(CacheVector::iterator vi = hi->second.begin();
          vi != hi->second.end();
          ++vi) {
        InlineCache* ic = *vi;
        int seen = ic->classes_seen();
        if(ic->seen_classes_overflow() > 0) {
          total++;
          overflow++;
        } else if(seen > 0) {
          total++;
          sizes[seen]++;
        }
      }
    }

    std::cerr << "IC Stats:\n";
    for(int i = 1; i < cTrackedICHits + 1; i++) {
      std::cerr << " " << i << ": " << sizes[i] << " "
                << ratio(sizes[i], total) << "%\n";
    }

    std::cerr << cTrackedICHits << "+: " << overflow << " "
              << ratio(overflow, total) << "%\n";

    // print out the mega-morphic ones
    std::cerr << "\nMegamorphic call sites:\n";

    for(CacheHash::iterator hi = caches_.begin();
        hi != caches_.end();
        ++hi) {
      for(CacheVector::iterator vi = hi->second.begin();
          vi != hi->second.end();
          ++vi) {
        InlineCache* ic = *vi;
        if(ic->seen_classes_overflow() > 0) {
          ic->print(state, std::cerr);
          std::cerr << "location: ";
          ic->print_location(state, std::cerr);
          std::cerr << "\n\n";
        }
      }
    }
  }

void AutohidingSplitter::setAutoHideEnabled(bool ah)
{
    if (ah==autoHideEnabled) {
        return;
    }

    autoHideEnabled=ah;
    if (autoHideEnabled) {
        expandedSizes = sizes();
        connect(this, SIGNAL(splitterMoved(int, int)), this, SLOT(updateAfterSplitterMoved(int, int)));
    } else {
        for(int i = 0; i < widgetAutohidden.count() ; ++i) {

void TraceGfx::DoRender(graph::Engine& engine)
{
	//Отрисовка путей
	for (Trace::Points::const_iterator iter = _trace->GetPoints().begin(); iter != _trace->GetPoints().end(); ++iter)
	{
		_libMat->material.SetDiffuse(*iter == _selPoint ? clrGreen : clrRed);

		_wayPnt->SetPos((*iter)->GetPos());
		_wayPnt->SetScale((*iter)->GetSize());			
		_wayPnt->Render(engine);		
	}

	//Отрисовка связей между путями
	Vec3Range resColor(D3DXVECTOR3(clrWhite / 2.0f), D3DXVECTOR3(clrWhite), Vec3Range::vdVolume);
	D3DXVECTOR3 upVec = engine.GetContext().GetCamera().GetDesc().dir;
	float iPath = 0.0f;
	float pathCnt = static_cast<float>(_trace->GetPathes().size());
	
	for (Trace::Pathes::const_iterator iter = _trace->GetPathes().begin(); iter != _trace->GetPathes().end(); ++iter, ++iPath)
	{
		WayPath* path = *iter;
		D3DXCOLOR pathColor = path == _selPath ? clrGreen : D3DXCOLOR(resColor.GetValue(iPath / (pathCnt - 1.0f)));
		res::VertexData vBuf;
		path->GetTriStripVBuf(vBuf, &upVec);
		if (vBuf.IsInit())
			DrawNodes(engine, vBuf.begin().Pos3(), vBuf.GetVertexCount() - 2, pathColor);
	}

	//Для выделенного узла свой цикл отрисовки
	if (_selNode && _selNode->GetNext())
	{
		D3DXVECTOR3 vBuf[4];
		_selNode->GetTile().GetVBuf(vBuf, 4, &upVec);
		DrawNodes(engine, vBuf, 4 - 2, clrGreen);
	}

	//Отрисовка связи выделения
	if (_pointLink)
	{
		D3DXVECTOR3 pos1 = _pointLink->GetPoint()->GetPos();
		D3DXVECTOR3 pos2 = _pointLink->GetPos();
		D3DXVECTOR3 dir = pos1 - pos2;
		D3DXVECTOR2 sizes(D3DXVec3Length(&dir), _pointLink->GetPoint()->GetSize());
		D3DXVec3Normalize(&dir, &dir);

		_sprite->SetPos((pos1 + pos2) / 2.0f);
		_sprite->SetDir(dir);
		_sprite->sizes = sizes;

		_libMat->material.SetDiffuse(clrGreen);
		_sprite->Render(engine);
	}
}

bool Shader::compile() {
    CORRADE_ASSERT(sources.size() > 1, "Shader::compile(): no files added", false);

    /* Array of source string pointers and their lengths */
    /** @todo Use `Containers::ArrayTuple` to avoid one allocation if it ever
        gets to be implemented (we need properly aligned memory too) */
    Containers::Array<const GLchar*> pointers(sources.size());
    Containers::Array<GLint> sizes(sources.size());
    for(std::size_t i = 0; i != sources.size(); ++i) {
        pointers[i] = static_cast<const GLchar*>(sources[i].data());
        sizes[i] = sources[i].size();
    }

    /* Create shader and set its source */
    glShaderSource(_id, sources.size(), pointers, sizes);

    /* Compile shader */
    glCompileShader(_id);

    /* Check compilation status */
    GLint success, logLength;
    glGetShaderiv(_id, GL_COMPILE_STATUS, &success);
    glGetShaderiv(_id, GL_INFO_LOG_LENGTH, &logLength);

    /* Error or warning message. The string is returned null-terminated, scrap
       the \0 at the end afterwards */
    std::string message(logLength, '\0');
    if(message.size() > 1)
        glGetShaderInfoLog(_id, message.size(), nullptr, &message[0]);
    message.resize(std::max(logLength, 1)-1);

    /* Show error log */
    if(!success) {
        Error out;
        out.setFlag(Debug::NewLineAtTheEnd, false);
        out.setFlag(Debug::SpaceAfterEachValue, false);
        out << "Shader: " << shaderName(_type)
            << " shader failed to compile with the following message:\n"
            << message;

    /* Or just message, if any */
    } else if(!message.empty()) {
        Error out;
        out.setFlag(Debug::NewLineAtTheEnd, false);
        out.setFlag(Debug::SpaceAfterEachValue, false);
        out << "Shader: " << shaderName(_type)
            << " shader was successfully compiled with the following message:\n"
            << message;
    }

    return success;
}