C++ (Cpp) Mat::unsafe_col Examples

Programming Language: C++ (Cpp)

Namespace/Package Name: arma

Class/Type: Mat

Method/Function: unsafe_col

Examples at hotexamples.com: 4

The `arma::mat::unsafe_col()` function in C++ is a part of the Armadillo library, which is a linear algebra library for C++. This function is used to access and manipulate particular columns of a matrix in an unsafe manner.

The syntax for using `unsafe_col()` is:

mat::unsafe_col(uword col_num);

where `col_num` is the column number to be accessed. The returned object is of type `vec`, which can be used for further operations.

Example 1:

#include 
#include 

using namespace std;
using namespace arma;

int main() {
  mat A = randu(3,3);
  vec b = A.unsafe_col(1);
  cout << b << endl;

  return 0;
}

This code initializes a 3x3 matrix `A` with random values, and then uses `unsafe_col()` to extract the second column of `A` into a vector `b`. The vector `b` is then printed to the console.

Example 2:

#include 
#include 

using namespace std;
using namespace arma;

int main() {
  mat A = randu(5,5);
  A.unsafe_col(3) = A.col(2) + A.col(4);
  cout << A << endl;

  return 0;
}

This code initializes a 5x5 matrix `A` with random values, and then uses `unsafe_col()` to assign values to the fourth column of `A` by adding the second and fifth columns of `A`. The resulting matrix `A` is then printed to the console. In both of these examples, the Armadillo library is used to perform linear algebra operations on the matrix object.

C++ (Cpp) Mat::unsafe_col - 4 examples found. These are the top rated real world C++ (Cpp) examples of arma::Mat::unsafe_col extracted from open source projects. You can rate examples to help us improve the quality of examples.

Frequently Used Methods

Show Hide

col(25)

set_size(21)

colptr(8)

memptr(8)

load(7)

row(4)

unsafe_col(4)

fill(4)

submat(4)

at(2)

transform(2)

t(2)

rows(2)

quiet_save(2)

num_rows(2)

num_cols(2)

resize(1)

size(1)

min(1)

max(1)

cols(1)

zeros(1)

Example #1

Show file

File: lsh_search_impl.hpp Project: 0x0all/mlpack

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;
}

Example #2

Show file

File: discrete_boundary_operator.cpp Project: getzze/bempp

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);
  }
}

Example #3

Show file

File: vr_class_reward_layer.hpp Project: YaweiZhao/mlpack

  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;
  }

Example #4

Show file

File: surface_normal_and_domain_index_dependent_function.hpp Project: huidong80/bempp

    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);
        }
    }