inline force_inline
double LSHSearch<SortPolicy>::BaseCase(arma::mat& distances,
arma::Mat<size_t>& neighbors,
const size_t queryIndex,
const size_t referenceIndex)
{
// If the datasets are the same, then this search is only using one dataset
// and we should not return identical points.
if ((&querySet == &referenceSet) && (queryIndex == referenceIndex))
return 0.0;
const double distance = metric::EuclideanDistance::Evaluate(
querySet.unsafe_col(queryIndex), referenceSet.unsafe_col(referenceIndex));
// If this distance is better than any of the current candidates, the
// SortDistance() function will give us the position to insert it into.
arma::vec queryDist = distances.unsafe_col(queryIndex);
arma::Col<size_t> queryIndices = neighbors.unsafe_col(queryIndex);
size_t insertPosition = SortPolicy::SortDistance(queryDist, queryIndices,
distance);
// SortDistance() returns (size_t() - 1) if we shouldn't add it.
if (insertPosition != (size_t() - 1))
InsertNeighbor(distances, neighbors, queryIndex, insertPosition,
referenceIndex, distance);
return distance;
}
void DiscreteBoundaryOperator<ValueType>::apply(
const TranspositionMode trans, const arma::Mat<ValueType> &x_in,
arma::Mat<ValueType> &y_inout, const ValueType alpha,
const ValueType beta) const {
bool transposed = (trans == TRANSPOSE || trans == CONJUGATE_TRANSPOSE);
if (x_in.n_rows != (transposed ? rowCount() : columnCount()))
throw std::invalid_argument("DiscreteBoundaryOperator::apply(): "
"vector x_in has invalid length");
if (y_inout.n_rows != (transposed ? columnCount() : rowCount()))
throw std::invalid_argument("DiscreteBoundaryOperator::apply(): "
"vector y_inout has invalid length");
if (x_in.n_cols != y_inout.n_cols)
throw std::invalid_argument("DiscreteBoundaryOperator::apply(): "
"vectors x_in and y_inout must have "
"the same number of columns");
for (size_t i = 0; i < x_in.n_cols; ++i) {
const arma::Col<ValueType> x_in_col = x_in.unsafe_col(i);
arma::Col<ValueType> y_inout_col = y_inout.unsafe_col(i);
applyBuiltInImpl(trans, x_in_col, y_inout_col, alpha, beta);
}
}
double Forward(const arma::Mat<eT>& input, const arma::Mat<eT>& target)
{
reward = 0;
arma::uword index = 0;
for (size_t i = 0; i < input.n_cols; i++)
{
input.unsafe_col(i).max(index);
reward = ((index + 1) == target(i)) * scale;
}
if (sizeAverage)
{
return -reward / input.n_cols;
}
return -reward;
}
virtual void evaluate(const GeometricalData<CoordinateType>& geomData,
arma::Mat<ValueType>& result) const {
const arma::Mat<CoordinateType>& points = geomData.globals;
const arma::Mat<CoordinateType>& normals = geomData.normals;
#ifndef NDEBUG
if ((int)points.n_rows != worldDimension() ||
(int)points.n_rows != worldDimension())
throw std::invalid_argument(
"SurfaceNormalAndDomainIndexDependentFunction::evaluate(): "
"incompatible world dimension");
#endif
const size_t pointCount = points.n_cols;
result.set_size(codomainDimension(), pointCount);
for (size_t i = 0; i < pointCount; ++i) {
arma::Col<ValueType> activeResultColumn = result.unsafe_col(i);
m_functor.evaluate(points.unsafe_col(i), normals.unsafe_col(i),
geomData.domainIndex, activeResultColumn);
}
}