bool SLEvaluatorConcrete<RT>::evaluate(const DMat<RT>& inputs, DMat<RT>& outputs)
{
if (varsPos.size() != inputs.numRows()*inputs.numColumns()) {
ERROR("inputs: the number of inputs does not match the number of entries in the inputs matrix");
std::cout << varsPos.size() << " != " << inputs.numRows()*inputs.numColumns() << std::endl;
return false;
}
size_t i=0;
for(size_t r=0; r<inputs.numRows(); r++)
for(size_t c=0; c<inputs.numColumns(); c++)
ring().set(values[varsPos[i++]],inputs.entry(r,c));
nIt = slp->mNodes.begin();
numInputsIt = slp->mNumInputs.begin();
inputPositionsIt = slp->mInputPositions.begin();
for (vIt = values.begin()+slp->inputCounter; vIt != values.end(); ++vIt)
computeNextNode();
if (slp->mOutputPositions.size() != outputs.numRows()*outputs.numColumns()) {
ERROR("outputs: the number of outputs does not match the number of entries in the outputs matrix");
std::cout << slp->mOutputPositions.size() << " != " << outputs.numRows() << " * " << outputs.numColumns() << std::endl;
return false;
}
i=0;
for(size_t r=0; r<outputs.numRows(); r++)
for(size_t c=0; c<outputs.numColumns(); c++)
ring().set(outputs.entry(r,c),values[ap(slp->mOutputPositions[i++])]);
return true;
}
void set(DMat<RT>& A, MatrixWindow wA, const DMat<RT>& B, MatrixWindow wB)
{
M2_ASSERT(wA.sameSize(wB));
long rA = wA.begin_row;
long rB = wB.begin_row;
for ( ; rA < wA.end_row; ++rA, ++rB)
{
long cA = wA.begin_column;
long cB = wB.begin_column;
for ( ; cA < wA.end_column; ++cA, ++cB)
A.ring().set(A.entry(rA,cA), B.entry(rB,cB));
}
}
void scalarMult(DMat<RT>& A, MatrixWindow wA, const typename RT::ElementType& c, const DMat<RT>& B, MatrixWindow wB)
{
M2_ASSERT(wA.sameSize(wB));
long rA = wA.begin_row;
long rB = wB.begin_row;
for ( ; rA < wA.end_row; ++rA, ++rB)
{
long cA = wA.begin_column;
long cB = wB.begin_column;
for ( ; cA < wA.end_column; ++cA, ++cB)
{
A.ring().mult(A.entry(rA,cA), c, B.entry(rB,cB));
}
}
}
void addTo(DMat<RT>& A, MatrixWindow wA, const DMat<RT>& B, MatrixWindow wB)
{
assert(wA.sameSize(wB));
long rA = wA.begin_row;
long rB = wB.begin_row;
for (; rA < wA.end_row; ++rA, ++rB)
{
long cA = wA.begin_column;
long cB = wB.begin_column;
for (; cA < wA.end_column; ++cA, ++cB)
{
auto& a = A.entry(rA, cA);
A.ring().add(a, a, B.entry(rB, cB));
}
}
}
void addMultipleTo(DMat<RT>& A, MatrixWindow wA, const typename RT::ElementType& c, const DMat<RT>& B, MatrixWindow wB)
{
M2_ASSERT(wA.sameSize(wB));
typename RT::ElementType tmp;
A.ring().init(tmp);
long rA = wA.begin_row;
long rB = wB.begin_row;
for ( ; rA < wA.end_row; ++rA, ++rB)
{
long cA = wA.begin_column;
long cB = wB.begin_column;
for ( ; cA < wA.end_column; ++cA, ++cB)
{
A.ring().mult(tmp, c, B.entry(rB,cB));
auto& a = A.entry(rA,cA);
A.ring().add(a, a, tmp);
}
}
A.ring().clear(tmp);
}
inline void norm2(const DMat<RT>& M, size_t n, typename RT::RealElementType& result)
{
const auto& C = M.ring();
const auto& R = C.real_ring();
typename RT::RealElementType c;
R.init(c);
R.set_zero(result);
for(size_t i=0; i<n; i++) {
C.abs_squared(c,M.entry(0,i));
R.add(result,result,c);
}
R.clear(c);
}
void scalarMultInPlace(DMat<RT>& A, MatrixWindow wA, const typename RT::ElementType& c)
{
M2_ASSERT(wA.sameSize(wB));
long rA = wA.begin_row;
for ( ; rA < wA.end_row; ++rA)
{
long cA = wA.begin_column;
for ( ; cA < wA.end_column; ++cA)
{
auto& a = A.entry(rA,cA);
A.ring().mult(a, a, c);
}
}
}
void setZero(DMat<RT>& A, MatrixWindow wA)
{
for (long rA = wA.begin_row; rA < wA.end_row; ++rA)
for (size_t cA = wA.begin_column; cA < wA.end_column; ++cA)
A.ring().set_zero(A.entry(rA,cA));
}
double ResF4toM2Interface::setDegreeZeroMap(SchreyerFrame& C,
DMat<RingType>& result,
int slanted_degree,
int lev)
// 'result' should be previously initialized, but will be resized.
// return value: -1 means (slanted_degree, lev) is out of range, and the zero matrix was returned.
// otherwise: the fraction of non-zero elements is returned.
{
// As above, get the size of the matrix, and 'newcols'
// Now we loop through the elements of degree 'slanted_degree + lev' at level 'lev'
const RingType& R = result.ring();
if (not (lev > 0 and lev <= C.maxLevel()))
{
result.resize(0,0);
return -1;
}
assert(lev > 0 and lev <= C.maxLevel());
int degree = slanted_degree + lev;
auto& thislevel = C.level(lev);
int ncols = 0;
for (auto p=thislevel.begin(); p != thislevel.end(); ++p)
{
if (p->mDegree == degree) ncols++;
}
auto& prevlevel = C.level(lev-1);
int* newcomps = new int[prevlevel.size()];
int nrows = 0;
for (int i=0; i<prevlevel.size(); i++)
if (prevlevel[i].mDegree == degree)
newcomps[i] = nrows++;
else
newcomps[i] = -1;
result.resize(nrows, ncols);
int col = 0;
long nnonzeros = 0;
for (auto p=thislevel.begin(); p != thislevel.end(); ++p)
{
if (p->mDegree != degree) continue;
auto& f = p->mSyzygy;
auto end = poly_iter(C.ring(), f, 1);
auto i = poly_iter(C.ring(), f);
for ( ; i != end; ++i)
{
long comp = C.monoid().get_component(i.monomial());
if (newcomps[comp] >= 0)
{
R.set_from_long(result.entry(newcomps[comp], col), C.gausser().coeff_to_int(i.coefficient()));
nnonzeros++;
}
}
++col;
}
double frac_nonzero = (nrows*ncols);
frac_nonzero = static_cast<double>(nnonzeros) / frac_nonzero;
delete[] newcomps;
return frac_nonzero;
}