void Avx2Mat4x4TestF64(const Matrix<double>& m1, const Matrix<double>& m2)
{
if (!Matrix<double>::IsConforming(m1, m2))
throw runtime_error("Non-conforming operands - Avx2Mat4x4TestF64");
const size_t nrows = m1.GetNumRows();
const size_t ncols = m1.GetNumCols();
if (nrows != 4 || ncols != 4)
throw runtime_error("Invalid size - Avx2Mat4x4TestF64");
Matrix<double> m3_a(nrows, ncols);
Matrix<double> m3_b(nrows, ncols);
Matrix<double>::Mul(m3_a, m1, m2);
Avx2Mat4x4MulF64_(m3_b.Data(), m1.Data(), m2.Data());
cout << "\nResults for Avx2Mat4x4TestF64\n";
cout << "\nMatrix m3_a\n";
cout << m3_a << endl;
cout << "\nMatrix m3_b\n";
cout << m3_b << endl;
double tr_a = m1.Trace();
double tr_b = Avx2Mat4x4TraceF64_(m1.Data());
cout << "tr_a = " << tr_a << '\n';
cout << "tr_b = " << tr_b << '\n';
}
Matrix SegmentorOTSU::DotDiv (const Matrix& left,
const Matrix& right
)
{
kkint32 maxNumOfRows = Max (left.NumOfRows (), right.NumOfRows ());
kkint32 maxNumOfCols = Max (left.NumOfCols (), right.NumOfCols ());
kkint32 minNumOfRows = Min (left.NumOfRows (), right.NumOfRows ());
kkint32 minNumOfCols = Min (left.NumOfCols (), right.NumOfCols ());
Matrix result (maxNumOfRows, maxNumOfCols);
double const * const * leftData = left.Data ();
double const * const * rightData = right.Data ();
double** resultData = result.DataNotConst ();
kkint32 r, c;
for (r = 0; r < minNumOfRows; ++r)
{
double const * leftDataRow = leftData[r];
double const * rightDataRow = rightData[r];
double* resultDataRow = resultData[r];
for (c = 0; c < minNumOfCols; ++c)
resultDataRow[c] = leftDataRow[c] / rightDataRow[c];
}
for (r = minNumOfRows; r < maxNumOfRows; ++r)
{
double* resultDataRow = resultData[r];
for (c = minNumOfCols; c < maxNumOfCols; ++c)
{
if ((r >= right.NumOfRows ()) || (c >= right.NumOfCols ()))
resultDataRow[c] = NaN;
else if (rightData[r][c] == 0.0)
resultDataRow[c] = NaN;
else
resultDataRow[c] = 0.0;
}
}
return result;
} /* DotDiv */
void renderFrame(void)
{
//glViewport(0, 0, 600, 800);
// Get parameters from Effect
Effect* effect = sprite.GetEffect();
GLint u_MVPMatrix_handle = glGetUniformLocation(effect->GetProgramHandle(),"u_MVPMatrix");
GLint a_Position_handle = glGetAttribLocation(effect->GetProgramHandle(), "a_Position");
GLint a_TexCoordinate = glGetAttribLocation(effect->GetProgramHandle(), "a_TexCoordinate");
GLint mTextureUniformHandle = glGetUniformLocation(effect->GetProgramHandle(), "u_Texture");
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
glUseProgram(sprite.GetEffect()->GetProgramHandle());
glActiveTexture(GL_TEXTURE0);
// Bind the texture to this unit.
Texture* texture = (Texture*)sprite.GetTexture();
const GLuint thandle = texture->GetTextureHandle();
glBindTexture(GL_TEXTURE_2D, thandle); //sprite.GetTexture()->GetTextureHandle());
// Tell the texture uniform sampler to use this texture in the shader by binding to texture unit 0.
glUniform1i(mTextureUniformHandle, 0);
// Set position attribute and MVP matrix uniform
glVertexAttribPointer(a_Position_handle, 3, GL_FLOAT, false, 0, Sprite::GetVertexPosStatic());
glEnableVertexAttribArray(a_Position_handle);
glVertexAttribPointer(a_TexCoordinate, 2, GL_FLOAT, false, 0, Sprite::GetVertexTexStatic());
glEnableVertexAttribArray(a_TexCoordinate);
const Matrix *proj;
proj = camera.GetProjection();
std::string s;
Matrix projworld;
Matrix world;
world = Matrix::Translation(0,0,zoom);
Matrix::Multiply(*proj,world, projworld);
glUniformMatrix4fv(u_MVPMatrix_handle, 1, false, projworld.Data());
std::cout << std::flush;
glDrawArrays(GL_TRIANGLES, 0, 6);
//glFlush();
}
void MatrixQuantizerCPU<ElemType>::QuantizeAsync(const Matrix<ElemType>& inMatrix, const Matrix<ElemType>& inResidual, QuantizedMatrix<ElemType>& outQMatrix, Matrix<ElemType>& outResidual, bool zeroThresholdFor1Bit)
{
// The outQMatrix should be on the CPU
// TODO: Support transferring the quantization output to a quantized matrix on the GPU
assert(outQMatrix.GetDeviceId() == CPUDEVICE);
size_t nBits = outQMatrix.GetNumBits();
size_t nRow = inMatrix.GetNumRows();
size_t nCol = inMatrix.GetNumCols();
// Verify that the different matrix parameters have matching dimensions
assert((outQMatrix.GetNumRows() == nRow) && (outQMatrix.GetNumCols() == nCol));
assert((inResidual.GetNumRows() == nRow) && (inResidual.GetNumCols() == nCol));
assert((outResidual.GetNumRows() == nRow) && (outResidual.GetNumCols() == nCol));
const size_t ldNbits = ValueQuantizer<ElemType>::ld(nBits);
#ifdef QUANTUSEPPL
Concurrency::parallel_for((size_t) 0, us.cols(), [&](size_t j)
#else
for (size_t j = 0; j < nCol; j++)
#endif
{
auto& qcol = *(outQMatrix.GetQuantizedColumn(j));
if (zeroThresholdFor1Bit)
{
// Explicit use of 'template' keyword is needed to compile with GCC
ColumnQuantizer<ElemType>::template ComputeRangeStatColj<true>(inMatrix.Data(), inResidual.Data(), (long) nRow, j, nBits, qcol.lower, qcol.upper);
}
else
{
// Explicit use of 'template' keyword is needed to compile with GCC
ColumnQuantizer<ElemType>::template ComputeRangeStatColj<false>(inMatrix.Data(), inResidual.Data(), (long) nRow, j, nBits, qcol.lower, qcol.upper);
}
ColumnQuantizer<ElemType> q(ldNbits, qcol.lower, qcol.upper);
if (zeroThresholdFor1Bit)
{
// Explicit use of 'template' keyword is needed to compile with GCC
q.template Quantize<true>(inMatrix.Data(), inResidual.Data(), (long) nRow, j, qcol.bits, outResidual.Data());
}
else
{
// Explicit use of 'template' keyword is needed to compile with GCC
q.template Quantize<false>(inMatrix.Data(), inResidual.Data(), (long) nRow, j, qcol.bits, outResidual.Data());
}
}
#ifdef QUANTUSEPPL
);
Matrix SegmentorOTSU::Power (const Matrix& left,
double right
)
{
kkuint32 numOfRows = left.NumOfRows ();
kkuint32 numOfCols = left.NumOfCols ();
Matrix result (numOfRows, numOfCols);
double const * const * leftData = left.Data ();
double** resultData = result.DataNotConst ();
kkuint32 r, c;
for (r = 0; r < numOfRows; ++r)
{
double const * leftDataRow = leftData[r];
double* resultDataRow = resultData[r];
for (c = 0; c < numOfCols; ++c)
resultDataRow[c] = pow (leftDataRow[c], right);
}
return result;
} /* Power */
void AvxMat4x4TransposeF32(Matrix<float>& m_src)
{
const size_t nr = 4;
const size_t nc = 4;
Matrix<float> m_des1(nr ,nc);
Matrix<float> m_des2(nr ,nc);
Matrix<float>::Transpose(m_des1, m_src);
AvxMat4x4TransposeF32_(m_des2.Data(), m_src.Data());
cout << fixed << setprecision(1);
m_src.SetOstream(12, " ");
m_des1.SetOstream(12, " ");
m_des2.SetOstream(12, " ");
cout << "Results for AvxMat4x4TransposeF32\n";
cout << "Matrix m_src \n" << m_src << '\n';
cout << "Matrix m_des1\n" << m_des1 << '\n';
cout << "Matrix m_des2\n" << m_des2 << '\n';
if (m_des1 != m_des2)
cout << "\nMatrix compare failed - AvxMat4x4TransposeF32\n";
}