Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

More consistent names for all delayed isometric classes and files. #98

Merged
merged 3 commits into from
May 17, 2024
Merged

More consistent names for all delayed isometric classes and files. #98

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
60a9b6d
More consistent names for all delayed isometric helper classes.
LTLA May 17, 2024
6b352ee
Cleaned up the docs.
LTLA May 17, 2024
07f7d52
Link back to DelayedArray in the class definition.
LTLA May 17, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
28 changes: 14 additions & 14 deletions include/tatami/isometric/arith_utils.hpp → ...ude/tatami/isometric/arithmetic_utils.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,20 +1,20 @@
#ifndef TATAMI_ARITH_UTILS_HPP
#define TATAMI_ARITH_UTILS_HPP
#ifndef TATAMI_ARITHMETIC_UTILS_HPP
#define TATAMI_ARITHMETIC_UTILS_HPP

#include <cmath>

/**
* @file arith_utils.hpp
* @file arithmetic_utils.hpp
*
* @brief Utilities for delayed arithmetic operations.
*/

namespace tatami {

/**
* Type of the delayed arithmetic operation.
* Type of arithmetic operation.
*/
enum class DelayedArithOp : char {
enum class ArithmeticOperation : char {
ADD,
SUBTRACT,
MULTIPLY,
Expand All @@ -27,19 +27,19 @@ enum class DelayedArithOp : char {
/**
* @cond
*/
template<DelayedArithOp op_, bool right_, typename Scalar_, typename Value_>
void delayed_arith_run(Value_& val, Scalar_ scalar) {
if constexpr(op_ == DelayedArithOp::ADD) {
template<ArithmeticOperation op_, bool right_, typename Scalar_, typename Value_>
void delayed_arithmetic_run(Value_& val, Scalar_ scalar) {
if constexpr(op_ == ArithmeticOperation::ADD) {
val += scalar;
} else if constexpr(op_ == DelayedArithOp::MULTIPLY) {
} else if constexpr(op_ == ArithmeticOperation::MULTIPLY) {
val *= scalar;
} else if constexpr(op_ == DelayedArithOp::SUBTRACT) {
} else if constexpr(op_ == ArithmeticOperation::SUBTRACT) {
if constexpr(right_) {
val -= scalar;
} else {
val = scalar - val;
}
} else if constexpr(op_ == DelayedArithOp::DIVIDE) {
} else if constexpr(op_ == ArithmeticOperation::DIVIDE) {
// Assume that either Value_ is an IEEE-754 float, or that division by
// zero is impossible in this context. We don't apply manual checks
// here to avoid performance degradation; we also don't check that the
Expand All @@ -50,19 +50,19 @@ void delayed_arith_run(Value_& val, Scalar_ scalar) {
} else {
val = scalar / val;
}
} else if constexpr(op_ == DelayedArithOp::POWER) {
} else if constexpr(op_ == ArithmeticOperation::POWER) {
if constexpr(right_) {
val = std::pow(val, scalar);
} else {
val = std::pow(scalar, val);
}
} else if constexpr(op_ == DelayedArithOp::MODULO) {
} else if constexpr(op_ == ArithmeticOperation::MODULO) {
if constexpr(right_) {
val = std::fmod(val, scalar);
} else {
val = std::fmod(scalar, val);
}
} else if constexpr(op_ == DelayedArithOp::INTEGER_DIVIDE) {
} else if constexpr(op_ == ArithmeticOperation::INTEGER_DIVIDE) {
if constexpr(right_) {
val = std::floor(val / scalar);
} else {
Expand Down
52 changes: 26 additions & 26 deletions ...etric/binary/DelayedBinaryIsometricOp.hpp → ...inary/DelayedBinaryIsometricOperation.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
#ifndef TATAMI_DELAYED_BINARY_ISOMETRIC_OP_H
#define TATAMI_DELAYED_BINARY_ISOMETRIC_OP_H
#ifndef TATAMI_DELAYED_BINARY_ISOMETRIC_OPERATION_H
#define TATAMI_DELAYED_BINARY_ISOMETRIC_OPERATION_H

#include "../../base/Matrix.hpp"
#include "../../utils/new_extractor.hpp"
Expand All @@ -14,16 +14,14 @@
* @file DelayedBinaryIsometricOp.hpp
*
* @brief Delayed binary isometric operations.
*
* This is equivalent to the class of the same name in the **DelayedArray** package.
*/

namespace tatami {

/**
* @cond
*/
namespace DelayedBinaryIsometricOp_internal {
namespace DelayedBinaryIsometricOperation_internal {

template<class Operation_, bool oracle_, typename Index_>
class MaybeOracleDepends {
Expand Down Expand Up @@ -488,23 +486,25 @@ class Sparse : public SparseExtractor<oracle_, Value_, Index_> {
*
* Implements any operation that takes two matrices of the same shape and returns another matrix of that shape.
* Each entry of the output matrix is a function of the corresponding values in the two input matrices.
* This operation is "delayed" in that it is only evaluated on request, e.g., with `DenseExtractor::fetch()` or friends.
* This operation is "delayed" in that it is only evaluated during data extraction, e.g., with `MyopicDenseExtractor::fetch()` or friends.
*
* This class is inspired by the `DelayedNaryIsoOp` class in the **DelayedArray** Bioconductor package.
*
* @tparam Value_ Type of matrix value.
* @tparam Index_ Type of index value.
* @tparam Operation_ Class implementing the operation.
* This should implement the same methods as `DelayedBinaryBasicMockHelper` or `DelayedBinaryAdvancedMockHelper`,
* @tparam Operation_ Helper class implementing the operation.
* This should implement the same methods as `DelayedBinaryIsometricMockBasic` or `DelayedBinaryIsometricMockAdvanced`,
* depending on whether it can take advantage of matrix sparsity.
*/
template<typename Value_, typename Index_, class Operation_>
class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {
class DelayedBinaryIsometricOperation : public Matrix<Value_, Index_> {
public:
/**
* @param left Pointer to the left matrix.
* @param right Pointer to the right matrix.
* @param operation Instance of the functor class.
*/
DelayedBinaryIsometricOp(std::shared_ptr<const Matrix<Value_, Index_> > left, std::shared_ptr<const Matrix<Value_, Index_> > right, Operation_ operation) :
DelayedBinaryIsometricOperation(std::shared_ptr<const Matrix<Value_, Index_> > left, std::shared_ptr<const Matrix<Value_, Index_> > right, Operation_ operation) :
my_left(std::move(left)), my_right(std::move(right)), my_operation(std::move(operation))
{
if (my_left->nrow() != my_right->nrow() || my_left->ncol() != my_right->ncol()) {
Expand Down Expand Up @@ -572,7 +572,7 @@ class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {
private:
template<bool oracle_>
std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > dense_simple_internal(bool row, MaybeOracle<oracle_, Index_> oracle, const Options& opt) const {
return std::make_unique<DelayedBinaryIsometricOp_internal::DenseSimpleFull<oracle_, Value_, Index_, Operation_> >(
return std::make_unique<DelayedBinaryIsometricOperation_internal::DenseSimpleFull<oracle_, Value_, Index_, Operation_> >(
my_left.get(),
my_right.get(),
my_operation,
Expand All @@ -584,7 +584,7 @@ class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {

template<bool oracle_>
std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > dense_simple_internal(bool row, MaybeOracle<oracle_, Index_> oracle, Index_ block_start, Index_ block_length, const Options& opt) const {
return std::make_unique<DelayedBinaryIsometricOp_internal::DenseSimpleBlock<oracle_, Value_, Index_, Operation_> >(
return std::make_unique<DelayedBinaryIsometricOperation_internal::DenseSimpleBlock<oracle_, Value_, Index_, Operation_> >(
my_left.get(),
my_right.get(),
my_operation,
Expand All @@ -598,7 +598,7 @@ class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {

template<bool oracle_>
std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > dense_simple_internal(bool row, MaybeOracle<oracle_, Index_> oracle, VectorPtr<Index_> indices_ptr, const Options& opt) const {
return std::make_unique<DelayedBinaryIsometricOp_internal::DenseSimpleIndex<oracle_, Value_, Index_, Operation_> >(
return std::make_unique<DelayedBinaryIsometricOperation_internal::DenseSimpleIndex<oracle_, Value_, Index_, Operation_> >(
my_left.get(),
my_right.get(),
my_operation,
Expand All @@ -611,7 +611,7 @@ class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {

template<bool oracle_>
std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > dense_expanded_internal(bool row, MaybeOracle<oracle_, Index_> oracle, const Options& opt) const {
return std::make_unique<DelayedBinaryIsometricOp_internal::DenseExpandedFull<oracle_, Value_, Index_, Operation_> >(
return std::make_unique<DelayedBinaryIsometricOperation_internal::DenseExpandedFull<oracle_, Value_, Index_, Operation_> >(
my_left.get(),
my_right.get(),
my_operation,
Expand All @@ -623,7 +623,7 @@ class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {

template<bool oracle_>
std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > dense_expanded_internal(bool row, MaybeOracle<oracle_, Index_> oracle, Index_ block_start, Index_ block_length, const Options& opt) const {
return std::make_unique<DelayedBinaryIsometricOp_internal::DenseExpandedBlock<oracle_, Value_, Index_, Operation_> >(
return std::make_unique<DelayedBinaryIsometricOperation_internal::DenseExpandedBlock<oracle_, Value_, Index_, Operation_> >(
my_left.get(),
my_right.get(),
my_operation,
Expand All @@ -637,7 +637,7 @@ class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {

template<bool oracle_>
std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > dense_expanded_internal(bool row, MaybeOracle<oracle_, Index_> oracle, VectorPtr<Index_> indices_ptr, const Options& opt) const {
return std::make_unique<DelayedBinaryIsometricOp_internal::DenseExpandedIndex<oracle_, Value_, Index_, Operation_> >(
return std::make_unique<DelayedBinaryIsometricOperation_internal::DenseExpandedIndex<oracle_, Value_, Index_, Operation_> >(
my_left.get(),
my_right.get(),
my_operation,
Expand Down Expand Up @@ -684,7 +684,7 @@ class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {
std::unique_ptr<SparseExtractor<oracle_, Value_, Index_> > sparse_internal(bool row, MaybeOracle<oracle_, Index_> oracle, const Options& opt) const {
if constexpr(is_advanced) {
if (my_is_sparse) {
return std::make_unique<DelayedBinaryIsometricOp_internal::Sparse<oracle_, Value_, Index_, Operation_> >(
return std::make_unique<DelayedBinaryIsometricOperation_internal::Sparse<oracle_, Value_, Index_, Operation_> >(
my_left.get(),
my_right.get(),
my_operation,
Expand All @@ -706,7 +706,7 @@ class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {
std::unique_ptr<SparseExtractor<oracle_, Value_, Index_> > sparse_internal(bool row, MaybeOracle<oracle_, Index_> oracle, Index_ block_start, Index_ block_length, const Options& opt) const {
if constexpr(is_advanced) {
if (my_is_sparse) {
return std::make_unique<DelayedBinaryIsometricOp_internal::Sparse<oracle_, Value_, Index_, Operation_> >(
return std::make_unique<DelayedBinaryIsometricOperation_internal::Sparse<oracle_, Value_, Index_, Operation_> >(
my_left.get(),
my_right.get(),
my_operation,
Expand All @@ -731,7 +731,7 @@ class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {
std::unique_ptr<SparseExtractor<oracle_, Value_, Index_> > sparse_internal(bool row, MaybeOracle<oracle_, Index_> oracle, VectorPtr<Index_> indices_ptr, const Options& opt) const {
if constexpr(is_advanced) {
if (my_is_sparse) {
return std::make_unique<DelayedBinaryIsometricOp_internal::Sparse<oracle_, Value_, Index_, Operation_> >(
return std::make_unique<DelayedBinaryIsometricOperation_internal::Sparse<oracle_, Value_, Index_, Operation_> >(
my_left.get(),
my_right.get(),
my_operation,
Expand Down Expand Up @@ -810,27 +810,27 @@ class DelayedBinaryIsometricOp : public Matrix<Value_, Index_> {
* @return Instance of a `DelayedBinaryIsometricOp` clas.
*/
template<typename Value_, typename Index_, class Operation_>
std::shared_ptr<Matrix<Value_, Index_> > make_DelayedBinaryIsometricOp(std::shared_ptr<const Matrix<Value_, Index_> > left, std::shared_ptr<const Matrix<Value_, Index_> > right, Operation_ op) {
typedef typename std::remove_reference<Operation_>::type Op_;
return std::shared_ptr<Matrix<Value_, Index_> >(new DelayedBinaryIsometricOp<Value_, Index_, Op_>(std::move(left), std::move(right), std::move(op)));
std::shared_ptr<Matrix<Value_, Index_> > make_DelayedBinaryIsometricOperation(std::shared_ptr<const Matrix<Value_, Index_> > left, std::shared_ptr<const Matrix<Value_, Index_> > right, Operation_ op) {
typedef typename std::remove_reference<Operation_>::type Operation2_;
return std::shared_ptr<Matrix<Value_, Index_> >(new DelayedBinaryIsometricOperation<Value_, Index_, Operation2_>(std::move(left), std::move(right), std::move(op)));
}

/**
* @cond
*/
// For automatic template deduction with non-const pointers.
template<typename Value_, typename Index_, class Operation_>
std::shared_ptr<Matrix<Value_, Index_> > make_DelayedBinaryIsometricOp(std::shared_ptr<Matrix<Value_, Index_> > left, std::shared_ptr<Matrix<Value_, Index_> > right, Operation_ op) {
typedef typename std::remove_reference<Operation_>::type Op_;
return std::shared_ptr<Matrix<Value_, Index_> >(new DelayedBinaryIsometricOp<Value_, Index_, Op_>(std::move(left), std::move(right), std::move(op)));
std::shared_ptr<Matrix<Value_, Index_> > make_DelayedBinaryIsometricOperation(std::shared_ptr<Matrix<Value_, Index_> > left, std::shared_ptr<Matrix<Value_, Index_> > right, Operation_ op) {
typedef typename std::remove_reference<Operation_>::type Operation2_;
return std::shared_ptr<Matrix<Value_, Index_> >(new DelayedBinaryIsometricOperation<Value_, Index_, Operation2_>(std::move(left), std::move(right), std::move(op)));
}
/**
* @endcond
*/

}

#include "arith_helpers.hpp"
#include "arithmetic_helpers.hpp"

#include "compare_helpers.hpp"

Expand Down
145 changes: 0 additions & 145 deletions include/tatami/isometric/binary/arith_helpers.hpp
View file
Open in desktop

This file was deleted.

Loading
Loading