Jules documentation

BASE_NDARRAY

BINARY_APPLY_COMBINATIONS

BINARY_APPLY_OPERATION

BINARY_COMBINATIONS

BINARY_EXPR_NDARRAY

BINARY_LEFT_TYPE_OPERATION

BINARY_OPERATION

BINARY_OPERATIONS_LIST

BINARY_RIGHT_TYPE_OPERATION

BINARY_TYPE_OPERATION

CHECK_BOUNDS

CHECK_STRIDE

CONTIGUOUS_ARRAY

INDIRECT_NDARRAY

JULES_ARRAY_BINARY_EXPR_ARRAY_H

JULES_ARRAY_BLAS_H

JULES_ARRAY_CONTIGUOUS_ARRAY_H

JULES_ARRAY_DETAIL_ALLOCATOR_H

JULES_ARRAY_DETAIL_COMMON_H

JULES_ARRAY_DETAIL_SLICING_H

JULES_ARRAY_FUNCTIONAL_H

JULES_ARRAY_IND_ARRAY_H

JULES_ARRAY_IO_H

JULES_ARRAY_NUMERIC_H

JULES_ARRAY_SLICE_H

JULES_ARRAY_UNARY_EXPR_ARRAY_H

JULES_BASE_ASYNC_H

JULES_BASE_NUMERIC_H

JULES_BASE_RANDOM_H

JULES_CORE_DEBUG_H

JULES_CORE_DETAIL_NUMBERS_H

JULES_CORE_META_H

JULES_CORE_RANGE_H

JULES_CORE_TYPE_H

JULES_DATAFRAME_COLUMN_H

JULES_DATAFRAME_DATAFRAME_H

JULES_DATAFRAME_DETAIL_COLUMN_MODEL_H

JULES_DATAFRAME_NUMERIC_H

JULES_DEBUG_LEVEL

JULES_DEFER

JULES_TOKEN_CONCAT

JULES_TOKEN_PASTE

OPERATIONS_LIST

REF_NDARRAY

UNARY_APPLY_OPERATION

UNARY_EXPR_NDARRAY

UNARY_OPERATION

UNARY_OPERATIONS_LIST

UNPACK

operator<<(std::ostream &, const jules::ref_array<T, 1> &)

operator<<(std::ostream &, const jules::ref_array<T, N> &)

jules

• Array

• Array<base_array<T, N>>

• Array<binary_expr_array<LhsIt, RhsIt, F, N>>

• Array<contiguous_array<T, N>>

• Array<ind_array<T, N>>

• Array<ref_array<T, N>>

• Array<unary_expr_array<It, F, N>>

• all(Iter, Sent) - Checks whether all elements in a Range or in the sequence [first, last) are true.

• all(const Rng &) - Checks whether all elements in a Range or in the sequence [first, last) are true.

• all_args()

• all_args(bool, Args &&…)

• any(Iter, Sent) - Checks whether any of the elements in a Range or in the sequence [first, last) are true.

• any(const Rng &) - Checks whether any of the elements in a Range or in the sequence [first, last) are true.

• any_args()

• any_args(bool, Args &&…)

• apply(const base_array<T, N> &, Operator &&)

• apply(const base_array<T, N> &, const base_array<U, N> &, Operator &&)

• apply(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &, Operator &&)

• apply(const base_array<T, N> &, const contiguous_array<U, N> &, Operator &&)

• apply(const base_array<T, N> &, const ind_array<U, N> &, Operator &&)

• apply(const base_array<T, N> &, const ref_array<U, N> &, Operator &&)

• apply(const base_array<T, N> &, const unary_expr_array<A, B, N> &, Operator &&)

• apply(const binary_expr_array<LhsIt, RhsIt, Op, N> &, Operator &&)

• apply(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &, Operator &&)

• apply(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &, Operator &&)

• apply(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &, Operator &&)

• apply(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &, Operator &&)

• apply(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &, Operator &&)

• apply(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &, Operator &&)

• apply(const contiguous_array<T, N> &, Operator &&)

• apply(const contiguous_array<T, N> &, const base_array<U, N> &, Operator &&)

• apply(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &, Operator &&)

• apply(const contiguous_array<T, N> &, const contiguous_array<U, N> &, Operator &&)

• apply(const contiguous_array<T, N> &, const ind_array<U, N> &, Operator &&)

• apply(const contiguous_array<T, N> &, const ref_array<U, N> &, Operator &&)

• apply(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &, Operator &&)

• apply(const ind_array<T, N> &, Operator &&)

• apply(const ind_array<T, N> &, const base_array<U, N> &, Operator &&)

• apply(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &, Operator &&)

• apply(const ind_array<T, N> &, const contiguous_array<U, N> &, Operator &&)

• apply(const ind_array<T, N> &, const ind_array<U, N> &, Operator &&)

• apply(const ind_array<T, N> &, const ref_array<U, N> &, Operator &&)

• apply(const ind_array<T, N> &, const unary_expr_array<A, B, N> &, Operator &&)

• apply(const ref_array<T, N> &, Operator &&)

• apply(const ref_array<T, N> &, const base_array<U, N> &, Operator &&)

• apply(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &, Operator &&)

• apply(const ref_array<T, N> &, const contiguous_array<U, N> &, Operator &&)

• apply(const ref_array<T, N> &, const ind_array<U, N> &, Operator &&)

• apply(const ref_array<T, N> &, const ref_array<U, N> &, Operator &&)

• apply(const ref_array<T, N> &, const unary_expr_array<A, B, N> &, Operator &&)

• apply(const unary_expr_array<It, Op, N> &, Operator &&)

• apply(const unary_expr_array<It, Op, N> &, const base_array<U, N> &, Operator &&)

• apply(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &, Operator &&)

• apply(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &, Operator &&)

• apply(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &, Operator &&)

• apply(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &, Operator &&)

• apply(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &, Operator &&)

• as_vector(A &&)

• as_vector(Args &&…)

• as_vector(Rng &&)

• base_array<T, 1> - 1-Dimensional concrete array.

• base_array - N-Dimensional concrete array.

• base_coercion_rules - Utility class to combine coercion rules.

• base_column

• base_dataframe

• base_slice<1> - 1D-Array specialization for slicing and dimensions representation.

• base_slice - Array slicing and dimensions representation.

• bernoulli_sample(index_t, numeric)

• bernoulli_sample(numeric)

• binary_expr_array

• coercion_rules - Default class with coercion rules for numeric and string classes.

• column

• contiguous_array

• count(Iter, Sent) - Returns the number of true elements in a Range or in the sequence [first, last).

• count(const Rng &) - Returns the number of true elements in a Range or in the sequence [first, last).

• dataframe

• discrete_index_sample(Rng &&)

• distance_t - Standard distance type.

• eval(const binary_expr_array<Lhs, Rhs, Op, N> &)

• eval(const unary_expr_array<It, Op, N> &)

• in_place

• in_place_t

• ind_array<T, 1> - 1-D Indirect array specialization.

• ind_array - Array indirect reference.

• index_t - Standard index type.

• integer - Standard signed type.

• length(Iter, Sent) - Returns either the length of a Range or the distance of a pair of iterators.

• length(const Rng &) - Returns either the length of a Range or the distance of a pair of iterators.

• make_expr_array(It, It, F &&, typename base_slice<M>::extent_type)

• make_expr_array(LhsIt, LhsIt, RhsIt, RhsIt, F &&, typename base_slice<M>::extent_type)

• matrix - (1) N-Dimensional array aliasing.

• max(Iter, Sent, T) - Returns either the maximum element in a Range or in the sequence [first, last).

• max(const Rng &, T) - Returns either the maximum element in a Range or in the sequence [first, last).

• min(Iter, Sent, T) - Returns either the minimum element in a Range or in the sequence [first, last).

• min(const Rng &, T) - Returns either the minimum element in a Range or in the sequence [first, last).

• move_ptr(T *&)

• ndarray - (1) N-Dimensional array aliasing.

• none(Iter, Sent) - Checks whether all elements in a Range or in the sequence [first, last) are false.

• none(const Rng &) - Checks whether all elements in a Range or in the sequence [first, last) are false.

• normal_pdf(const A &, T, T)

• normal_pdf(const T &, const T &, const T &)

• numeric - Standard numeric type.

• numeric_rule - Coercion rules for numeric type.

• numeric_traits

• operator!(const base_array<T, N> &)

• operator!(const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator!(const contiguous_array<T, N> &)

• operator!(const ind_array<T, N> &)

• operator!(const ref_array<T, N> &)

• operator!(const unary_expr_array<It, Op, N> &)

• operator!=(U, const base_array<T, N> &)

• operator!=(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator!=(U, const contiguous_array<T, N> &)

• operator!=(U, const ind_array<T, N> &)

• operator!=(U, const ref_array<T, N> &)

• operator!=(U, const unary_expr_array<It, Op, N> &)

• operator!=(const base_array<T, N> &, U)

• operator!=(const base_array<T, N> &, const base_array<U, N> &)

• operator!=(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator!=(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator!=(const base_array<T, N> &, const ind_array<U, N> &)

• operator!=(const base_array<T, N> &, const ref_array<U, N> &)

• operator!=(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator!=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator!=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator!=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator!=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator!=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator!=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator!=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator!=(const contiguous_array<T, N> &, U)

• operator!=(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator!=(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator!=(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator!=(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator!=(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator!=(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator!=(const ind_array<T, N> &, U)

• operator!=(const ind_array<T, N> &, const base_array<U, N> &)

• operator!=(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator!=(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator!=(const ind_array<T, N> &, const ind_array<U, N> &)

• operator!=(const ind_array<T, N> &, const ref_array<U, N> &)

• operator!=(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator!=(const ref_array<T, N> &, U)

• operator!=(const ref_array<T, N> &, const base_array<U, N> &)

• operator!=(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator!=(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator!=(const ref_array<T, N> &, const ind_array<U, N> &)

• operator!=(const ref_array<T, N> &, const ref_array<U, N> &)

• operator!=(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator!=(const unary_expr_array<It, Op, N> &, U)

• operator!=(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator!=(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator!=(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator!=(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator!=(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator!=(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator%(U, const base_array<T, N> &)

• operator%(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator%(U, const contiguous_array<T, N> &)

• operator%(U, const ind_array<T, N> &)

• operator%(U, const ref_array<T, N> &)

• operator%(U, const unary_expr_array<It, Op, N> &)

• operator%(const base_array<T, N> &, U)

• operator%(const base_array<T, N> &, const base_array<U, N> &)

• operator%(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator%(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator%(const base_array<T, N> &, const ind_array<U, N> &)

• operator%(const base_array<T, N> &, const ref_array<U, N> &)

• operator%(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator%(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator%(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator%(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator%(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator%(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator%(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator%(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator%(const contiguous_array<T, N> &, U)

• operator%(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator%(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator%(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator%(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator%(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator%(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator%(const ind_array<T, N> &, U)

• operator%(const ind_array<T, N> &, const base_array<U, N> &)

• operator%(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator%(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator%(const ind_array<T, N> &, const ind_array<U, N> &)

• operator%(const ind_array<T, N> &, const ref_array<U, N> &)

• operator%(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator%(const ref_array<T, N> &, U)

• operator%(const ref_array<T, N> &, const base_array<U, N> &)

• operator%(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator%(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator%(const ref_array<T, N> &, const ind_array<U, N> &)

• operator%(const ref_array<T, N> &, const ref_array<U, N> &)

• operator%(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator%(const unary_expr_array<It, Op, N> &, U)

• operator%(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator%(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator%(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator%(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator%(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator%(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator&&(U, const base_array<T, N> &)

• operator&&(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator&&(U, const contiguous_array<T, N> &)

• operator&&(U, const ind_array<T, N> &)

• operator&&(U, const ref_array<T, N> &)

• operator&&(U, const unary_expr_array<It, Op, N> &)

• operator&&(const base_array<T, N> &, U)

• operator&&(const base_array<T, N> &, const base_array<U, N> &)

• operator&&(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator&&(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator&&(const base_array<T, N> &, const ind_array<U, N> &)

• operator&&(const base_array<T, N> &, const ref_array<U, N> &)

• operator&&(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator&&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator&&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator&&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator&&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator&&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator&&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator&&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator&&(const contiguous_array<T, N> &, U)

• operator&&(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator&&(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator&&(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator&&(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator&&(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator&&(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator&&(const ind_array<T, N> &, U)

• operator&&(const ind_array<T, N> &, const base_array<U, N> &)

• operator&&(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator&&(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator&&(const ind_array<T, N> &, const ind_array<U, N> &)

• operator&&(const ind_array<T, N> &, const ref_array<U, N> &)

• operator&&(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator&&(const ref_array<T, N> &, U)

• operator&&(const ref_array<T, N> &, const base_array<U, N> &)

• operator&&(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator&&(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator&&(const ref_array<T, N> &, const ind_array<U, N> &)

• operator&&(const ref_array<T, N> &, const ref_array<U, N> &)

• operator&&(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator&&(const unary_expr_array<It, Op, N> &, U)

• operator&&(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator&&(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator&&(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator&&(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator&&(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator&&(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator&(U, const base_array<T, N> &)

• operator&(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator&(U, const contiguous_array<T, N> &)

• operator&(U, const ind_array<T, N> &)

• operator&(U, const ref_array<T, N> &)

• operator&(U, const unary_expr_array<It, Op, N> &)

• operator&(const base_array<T, N> &, U)

• operator&(const base_array<T, N> &, const base_array<U, N> &)

• operator&(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator&(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator&(const base_array<T, N> &, const ind_array<U, N> &)

• operator&(const base_array<T, N> &, const ref_array<U, N> &)

• operator&(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator&(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator&(const contiguous_array<T, N> &, U)

• operator&(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator&(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator&(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator&(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator&(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator&(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator&(const ind_array<T, N> &, U)

• operator&(const ind_array<T, N> &, const base_array<U, N> &)

• operator&(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator&(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator&(const ind_array<T, N> &, const ind_array<U, N> &)

• operator&(const ind_array<T, N> &, const ref_array<U, N> &)

• operator&(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator&(const ref_array<T, N> &, U)

• operator&(const ref_array<T, N> &, const base_array<U, N> &)

• operator&(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator&(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator&(const ref_array<T, N> &, const ind_array<U, N> &)

• operator&(const ref_array<T, N> &, const ref_array<U, N> &)

• operator&(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator&(const unary_expr_array<It, Op, N> &, U)

• operator&(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator&(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator&(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator&(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator&(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator&(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator*(U, const base_array<T, N> &)

• operator*(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator*(U, const contiguous_array<T, N> &)

• operator*(U, const ind_array<T, N> &)

• operator*(U, const ref_array<T, N> &)

• operator*(U, const unary_expr_array<It, Op, N> &)

• operator*(const base_array<T, N> &, U)

• operator*(const base_array<T, N> &, const base_array<U, N> &)

• operator*(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator*(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator*(const base_array<T, N> &, const ind_array<U, N> &)

• operator*(const base_array<T, N> &, const ref_array<U, N> &)

• operator*(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator*(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator*(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator*(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator*(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator*(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator*(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator*(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator*(const contiguous_array<T, N> &, U)

• operator*(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator*(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator*(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator*(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator*(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator*(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator*(const ind_array<T, N> &, U)

• operator*(const ind_array<T, N> &, const base_array<U, N> &)

• operator*(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator*(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator*(const ind_array<T, N> &, const ind_array<U, N> &)

• operator*(const ind_array<T, N> &, const ref_array<U, N> &)

• operator*(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator*(const ref_array<T, N> &, U)

• operator*(const ref_array<T, N> &, const base_array<U, N> &)

• operator*(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator*(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator*(const ref_array<T, N> &, const ind_array<U, N> &)

• operator*(const ref_array<T, N> &, const ref_array<U, N> &)

• operator*(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator*(const unary_expr_array<It, Op, N> &, U)

• operator*(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator*(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator*(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator*(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator*(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator*(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator+(U, const base_array<T, N> &)

• operator+(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator+(U, const contiguous_array<T, N> &)

• operator+(U, const ind_array<T, N> &)

• operator+(U, const ref_array<T, N> &)

• operator+(U, const unary_expr_array<It, Op, N> &)

• operator+(const base_array<T, N> &)

• operator+(const base_array<T, N> &, U)

• operator+(const base_array<T, N> &, const base_array<U, N> &)

• operator+(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator+(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator+(const base_array<T, N> &, const ind_array<U, N> &)

• operator+(const base_array<T, N> &, const ref_array<U, N> &)

• operator+(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator+(const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator+(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator+(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator+(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator+(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator+(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator+(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator+(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator+(const contiguous_array<T, N> &)

• operator+(const contiguous_array<T, N> &, U)

• operator+(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator+(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator+(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator+(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator+(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator+(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator+(const ind_array<T, N> &)

• operator+(const ind_array<T, N> &, U)

• operator+(const ind_array<T, N> &, const base_array<U, N> &)

• operator+(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator+(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator+(const ind_array<T, N> &, const ind_array<U, N> &)

• operator+(const ind_array<T, N> &, const ref_array<U, N> &)

• operator+(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator+(const ref_array<T, N> &)

• operator+(const ref_array<T, N> &, U)

• operator+(const ref_array<T, N> &, const base_array<U, N> &)

• operator+(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator+(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator+(const ref_array<T, N> &, const ind_array<U, N> &)

• operator+(const ref_array<T, N> &, const ref_array<U, N> &)

• operator+(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator+(const unary_expr_array<It, Op, N> &)

• operator+(const unary_expr_array<It, Op, N> &, U)

• operator+(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator+(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator+(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator+(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator+(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator+(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator-(U, const base_array<T, N> &)

• operator-(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator-(U, const contiguous_array<T, N> &)

• operator-(U, const ind_array<T, N> &)

• operator-(U, const ref_array<T, N> &)

• operator-(U, const unary_expr_array<It, Op, N> &)

• operator-(const base_array<T, N> &)

• operator-(const base_array<T, N> &, U)

• operator-(const base_array<T, N> &, const base_array<U, N> &)

• operator-(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator-(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator-(const base_array<T, N> &, const ind_array<U, N> &)

• operator-(const base_array<T, N> &, const ref_array<U, N> &)

• operator-(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator-(const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator-(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator-(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator-(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator-(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator-(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator-(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator-(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator-(const contiguous_array<T, N> &)

• operator-(const contiguous_array<T, N> &, U)

• operator-(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator-(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator-(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator-(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator-(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator-(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator-(const ind_array<T, N> &)

• operator-(const ind_array<T, N> &, U)

• operator-(const ind_array<T, N> &, const base_array<U, N> &)

• operator-(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator-(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator-(const ind_array<T, N> &, const ind_array<U, N> &)

• operator-(const ind_array<T, N> &, const ref_array<U, N> &)

• operator-(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator-(const ref_array<T, N> &)

• operator-(const ref_array<T, N> &, U)

• operator-(const ref_array<T, N> &, const base_array<U, N> &)

• operator-(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator-(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator-(const ref_array<T, N> &, const ind_array<U, N> &)

• operator-(const ref_array<T, N> &, const ref_array<U, N> &)

• operator-(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator-(const unary_expr_array<It, Op, N> &)

• operator-(const unary_expr_array<It, Op, N> &, U)

• operator-(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator-(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator-(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator-(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator-(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator-(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator/(U, const base_array<T, N> &)

• operator/(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator/(U, const contiguous_array<T, N> &)

• operator/(U, const ind_array<T, N> &)

• operator/(U, const ref_array<T, N> &)

• operator/(U, const unary_expr_array<It, Op, N> &)

• operator/(const base_array<T, N> &, U)

• operator/(const base_array<T, N> &, const base_array<U, N> &)

• operator/(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator/(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator/(const base_array<T, N> &, const ind_array<U, N> &)

• operator/(const base_array<T, N> &, const ref_array<U, N> &)

• operator/(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator/(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator/(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator/(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator/(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator/(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator/(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator/(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator/(const contiguous_array<T, N> &, U)

• operator/(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator/(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator/(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator/(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator/(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator/(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator/(const ind_array<T, N> &, U)

• operator/(const ind_array<T, N> &, const base_array<U, N> &)

• operator/(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator/(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator/(const ind_array<T, N> &, const ind_array<U, N> &)

• operator/(const ind_array<T, N> &, const ref_array<U, N> &)

• operator/(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator/(const ref_array<T, N> &, U)

• operator/(const ref_array<T, N> &, const base_array<U, N> &)

• operator/(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator/(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator/(const ref_array<T, N> &, const ind_array<U, N> &)

• operator/(const ref_array<T, N> &, const ref_array<U, N> &)

• operator/(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator/(const unary_expr_array<It, Op, N> &, U)

• operator/(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator/(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator/(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator/(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator/(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator/(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator<(U, const base_array<T, N> &)

• operator<(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator<(U, const contiguous_array<T, N> &)

• operator<(U, const ind_array<T, N> &)

• operator<(U, const ref_array<T, N> &)

• operator<(U, const unary_expr_array<It, Op, N> &)

• operator<(const base_array<T, N> &, U)

• operator<(const base_array<T, N> &, const base_array<U, N> &)

• operator<(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator<(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator<(const base_array<T, N> &, const ind_array<U, N> &)

• operator<(const base_array<T, N> &, const ref_array<U, N> &)

• operator<(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator<(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator<(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator<(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator<(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator<(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator<(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator<(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator<(const contiguous_array<T, N> &, U)

• operator<(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator<(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator<(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator<(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator<(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator<(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator<(const ind_array<T, N> &, U)

• operator<(const ind_array<T, N> &, const base_array<U, N> &)

• operator<(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator<(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator<(const ind_array<T, N> &, const ind_array<U, N> &)

• operator<(const ind_array<T, N> &, const ref_array<U, N> &)

• operator<(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator<(const ref_array<T, N> &, U)

• operator<(const ref_array<T, N> &, const base_array<U, N> &)

• operator<(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator<(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator<(const ref_array<T, N> &, const ind_array<U, N> &)

• operator<(const ref_array<T, N> &, const ref_array<U, N> &)

• operator<(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator<(const unary_expr_array<It, Op, N> &, U)

• operator<(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator<(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator<(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator<(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator<(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator<(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator<<(std::ostream &, const base_dataframe<Coercion> &)

• operator<=(U, const base_array<T, N> &)

• operator<=(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator<=(U, const contiguous_array<T, N> &)

• operator<=(U, const ind_array<T, N> &)

• operator<=(U, const ref_array<T, N> &)

• operator<=(U, const unary_expr_array<It, Op, N> &)

• operator<=(const base_array<T, N> &, U)

• operator<=(const base_array<T, N> &, const base_array<U, N> &)

• operator<=(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator<=(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator<=(const base_array<T, N> &, const ind_array<U, N> &)

• operator<=(const base_array<T, N> &, const ref_array<U, N> &)

• operator<=(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator<=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator<=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator<=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator<=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator<=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator<=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator<=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator<=(const contiguous_array<T, N> &, U)

• operator<=(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator<=(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator<=(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator<=(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator<=(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator<=(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator<=(const ind_array<T, N> &, U)

• operator<=(const ind_array<T, N> &, const base_array<U, N> &)

• operator<=(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator<=(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator<=(const ind_array<T, N> &, const ind_array<U, N> &)

• operator<=(const ind_array<T, N> &, const ref_array<U, N> &)

• operator<=(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator<=(const ref_array<T, N> &, U)

• operator<=(const ref_array<T, N> &, const base_array<U, N> &)

• operator<=(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator<=(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator<=(const ref_array<T, N> &, const ind_array<U, N> &)

• operator<=(const ref_array<T, N> &, const ref_array<U, N> &)

• operator<=(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator<=(const unary_expr_array<It, Op, N> &, U)

• operator<=(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator<=(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator<=(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator<=(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator<=(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator<=(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator==(U, const base_array<T, N> &)

• operator==(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator==(U, const contiguous_array<T, N> &)

• operator==(U, const ind_array<T, N> &)

• operator==(U, const ref_array<T, N> &)

• operator==(U, const unary_expr_array<It, Op, N> &)

• operator==(const base_array<T, N> &, U)

• operator==(const base_array<T, N> &, const base_array<U, N> &)

• operator==(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator==(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator==(const base_array<T, N> &, const ind_array<U, N> &)

• operator==(const base_array<T, N> &, const ref_array<U, N> &)

• operator==(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator==(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator==(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator==(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator==(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator==(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator==(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator==(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator==(const contiguous_array<T, N> &, U)

• operator==(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator==(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator==(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator==(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator==(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator==(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator==(const ind_array<T, N> &, U)

• operator==(const ind_array<T, N> &, const base_array<U, N> &)

• operator==(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator==(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator==(const ind_array<T, N> &, const ind_array<U, N> &)

• operator==(const ind_array<T, N> &, const ref_array<U, N> &)

• operator==(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator==(const ref_array<T, N> &, U)

• operator==(const ref_array<T, N> &, const base_array<U, N> &)

• operator==(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator==(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator==(const ref_array<T, N> &, const ind_array<U, N> &)

• operator==(const ref_array<T, N> &, const ref_array<U, N> &)

• operator==(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator==(const unary_expr_array<It, Op, N> &, U)

• operator==(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator==(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator==(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator==(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator==(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator==(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator>(U, const base_array<T, N> &)

• operator>(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator>(U, const contiguous_array<T, N> &)

• operator>(U, const ind_array<T, N> &)

• operator>(U, const ref_array<T, N> &)

• operator>(U, const unary_expr_array<It, Op, N> &)

• operator>(const base_array<T, N> &, U)

• operator>(const base_array<T, N> &, const base_array<U, N> &)

• operator>(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator>(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator>(const base_array<T, N> &, const ind_array<U, N> &)

• operator>(const base_array<T, N> &, const ref_array<U, N> &)

• operator>(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator>(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator>(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator>(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator>(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator>(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator>(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator>(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator>(const contiguous_array<T, N> &, U)

• operator>(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator>(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator>(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator>(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator>(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator>(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator>(const ind_array<T, N> &, U)

• operator>(const ind_array<T, N> &, const base_array<U, N> &)

• operator>(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator>(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator>(const ind_array<T, N> &, const ind_array<U, N> &)

• operator>(const ind_array<T, N> &, const ref_array<U, N> &)

• operator>(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator>(const ref_array<T, N> &, U)

• operator>(const ref_array<T, N> &, const base_array<U, N> &)

• operator>(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator>(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator>(const ref_array<T, N> &, const ind_array<U, N> &)

• operator>(const ref_array<T, N> &, const ref_array<U, N> &)

• operator>(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator>(const unary_expr_array<It, Op, N> &, U)

• operator>(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator>(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator>(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator>(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator>(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator>(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator>=(U, const base_array<T, N> &)

• operator>=(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator>=(U, const contiguous_array<T, N> &)

• operator>=(U, const ind_array<T, N> &)

• operator>=(U, const ref_array<T, N> &)

• operator>=(U, const unary_expr_array<It, Op, N> &)

• operator>=(const base_array<T, N> &, U)

• operator>=(const base_array<T, N> &, const base_array<U, N> &)

• operator>=(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator>=(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator>=(const base_array<T, N> &, const ind_array<U, N> &)

• operator>=(const base_array<T, N> &, const ref_array<U, N> &)

• operator>=(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator>=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator>=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator>=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator>=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator>=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator>=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator>=(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator>=(const contiguous_array<T, N> &, U)

• operator>=(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator>=(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator>=(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator>=(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator>=(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator>=(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator>=(const ind_array<T, N> &, U)

• operator>=(const ind_array<T, N> &, const base_array<U, N> &)

• operator>=(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator>=(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator>=(const ind_array<T, N> &, const ind_array<U, N> &)

• operator>=(const ind_array<T, N> &, const ref_array<U, N> &)

• operator>=(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator>=(const ref_array<T, N> &, U)

• operator>=(const ref_array<T, N> &, const base_array<U, N> &)

• operator>=(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator>=(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator>=(const ref_array<T, N> &, const ind_array<U, N> &)

• operator>=(const ref_array<T, N> &, const ref_array<U, N> &)

• operator>=(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator>=(const unary_expr_array<It, Op, N> &, U)

• operator>=(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator>=(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator>=(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator>=(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator>=(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator>=(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• operator>>(std::istream &, base_dataframe<Coercion> &)

• operator^(U, const base_array<T, N> &)

• operator^(U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator^(U, const contiguous_array<T, N> &)

• operator^(U, const ind_array<T, N> &)

• operator^(U, const ref_array<T, N> &)

• operator^(U, const unary_expr_array<It, Op, N> &)

• operator^(const base_array<T, N> &, U)

• operator^(const base_array<T, N> &, const base_array<U, N> &)

• operator^(const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator^(const base_array<T, N> &, const contiguous_array<U, N> &)

• operator^(const base_array<T, N> &, const ind_array<U, N> &)

• operator^(const base_array<T, N> &, const ref_array<U, N> &)

• operator^(const base_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator^(const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)

• operator^(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)

• operator^(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator^(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)

• operator^(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)

• operator^(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)

• operator^(const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)

• operator^(const contiguous_array<T, N> &, U)

• operator^(const contiguous_array<T, N> &, const base_array<U, N> &)

• operator^(const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator^(const contiguous_array<T, N> &, const contiguous_array<U, N> &)

• operator^(const contiguous_array<T, N> &, const ind_array<U, N> &)

• operator^(const contiguous_array<T, N> &, const ref_array<U, N> &)

• operator^(const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator^(const ind_array<T, N> &, U)

• operator^(const ind_array<T, N> &, const base_array<U, N> &)

• operator^(const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator^(const ind_array<T, N> &, const contiguous_array<U, N> &)

• operator^(const ind_array<T, N> &, const ind_array<U, N> &)

• operator^(const ind_array<T, N> &, const ref_array<U, N> &)

• operator^(const ind_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator^(const ref_array<T, N> &, U)

• operator^(const ref_array<T, N> &, const base_array<U, N> &)

• operator^(const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)

• operator^(const ref_array<T, N> &, const contiguous_array<U, N> &)

• operator^(const ref_array<T, N> &, const ind_array<U, N> &)

• operator^(const ref_array<T, N> &, const ref_array<U, N> &)

• operator^(const ref_array<T, N> &, const unary_expr_array<A, B, N> &)

• operator^(const unary_expr_array<It, Op, N> &, U)

• operator^(const unary_expr_array<It, Op, N> &, const base_array<U, N> &)

• operator^(const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)

• operator^(const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)

• operator^(const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)

• operator^(const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)

• operator^(const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)

• [operator

  (U, const base_array<T, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const base_array<T, N> &)”)

• [operator

  (U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)”)

• [operator

  (U, const contiguous_array<T, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const contiguous_array<T, N> &)”)

• [operator

  (U, const ind_array<T, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const ind_array<T, N> &)”)

• [operator

  (U, const ref_array<T, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const ref_array<T, N> &)”)

• [operator

  (U, const unary_expr_array<It, Op, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const unary_expr_array<It, Op, N> &)”)

• [operator

  (const base_array<T, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, U)”)

• [operator

  (const base_array<T, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const base_array<U, N> &)”)

• [operator

  (const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const base_array<T, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const base_array<T, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const ind_array<U, N> &)”)

• [operator

  (const base_array<T, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const ref_array<U, N> &)”)

• [operator

  (const base_array<T, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (const contiguous_array<T, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, U)”)

• [operator

  (const contiguous_array<T, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const base_array<U, N> &)”)

• [operator

  (const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const contiguous_array<T, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const contiguous_array<T, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const ind_array<U, N> &)”)

• [operator

  (const contiguous_array<T, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const ref_array<U, N> &)”)

• [operator

  (const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (const ind_array<T, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, U)”)

• [operator

  (const ind_array<T, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const base_array<U, N> &)”)

• [operator

  (const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const ind_array<T, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const ind_array<T, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const ind_array<U, N> &)”)

• [operator

  (const ind_array<T, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const ref_array<U, N> &)”)

• [operator

  (const ind_array<T, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (const ref_array<T, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, U)”)

• [operator

  (const ref_array<T, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const base_array<U, N> &)”)

• [operator

  (const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const ref_array<T, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const ref_array<T, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const ind_array<U, N> &)”)

• [operator

  (const ref_array<T, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const ref_array<U, N> &)”)

• [operator

  (const ref_array<T, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, U)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const base_array<U, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (U, const base_array<T, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const base_array<T, N> &)”)

• [operator

  (U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const binary_expr_array<LhsIt, RhsIt, Op, N> &)”)

• [operator

  (U, const contiguous_array<T, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const contiguous_array<T, N> &)”)

• [operator

  (U, const ind_array<T, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const ind_array<T, N> &)”)

• [operator

  (U, const ref_array<T, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const ref_array<T, N> &)”)

• [operator

  (U, const unary_expr_array<It, Op, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (U, const unary_expr_array<It, Op, N> &)”)

• [operator

  (const base_array<T, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, U)”)

• [operator

  (const base_array<T, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const base_array<U, N> &)”)

• [operator

  (const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const base_array<T, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const base_array<T, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const ind_array<U, N> &)”)

• [operator

  (const base_array<T, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const ref_array<U, N> &)”)

• [operator

  (const base_array<T, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const base_array<T, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, U)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const base_array<U, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ind_array<U, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const ref_array<U, N> &)”)

• [operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const binary_expr_array<LhsIt, RhsIt, Op, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (const contiguous_array<T, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, U)”)

• [operator

  (const contiguous_array<T, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const base_array<U, N> &)”)

• [operator

  (const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const contiguous_array<T, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const contiguous_array<T, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const ind_array<U, N> &)”)

• [operator

  (const contiguous_array<T, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const ref_array<U, N> &)”)

• [operator

  (const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const contiguous_array<T, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (const ind_array<T, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, U)”)

• [operator

  (const ind_array<T, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const base_array<U, N> &)”)

• [operator

  (const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const ind_array<T, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const ind_array<T, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const ind_array<U, N> &)”)

• [operator

  (const ind_array<T, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const ref_array<U, N> &)”)

• [operator

  (const ind_array<T, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ind_array<T, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (const ref_array<T, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, U)”)

• [operator

  (const ref_array<T, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const base_array<U, N> &)”)

• [operator

  (const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const ref_array<T, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const ref_array<T, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const ind_array<U, N> &)”)

• [operator

  (const ref_array<T, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const ref_array<U, N> &)”)

• [operator

  (const ref_array<T, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const ref_array<T, N> &, const unary_expr_array<A, B, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, U)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, U)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const base_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const base_array<U, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const binary_expr_array<A, B, C, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const contiguous_array<U, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const ind_array<U, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const ref_array<U, N> &)”)

• [operator

  (const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)](doc_array__functional.html#array/functional.hpp “jules::operator

  (const unary_expr_array<It, Op, N> &, const unary_expr_array<A, B, N> &)”)

• operator~(const base_array<T, N> &)

• operator~(const binary_expr_array<LhsIt, RhsIt, Op, N> &)

• operator~(const contiguous_array<T, N> &)

• operator~(const ind_array<T, N> &)

• operator~(const ref_array<T, N> &)

• operator~(const unary_expr_array<It, Op, N> &)

• prod(Iter, Sent, T) - Returns either the product of the elements in a Range or in the sequence [first, last).

• prod(const Rng &, T) - Returns either the product of the elements in a Range or in the sequence [first, last).

• prod_args()

• prod_args(const T &, Args &&…)

• random_engine

• recursive_initializer_list<T, 0>

• recursive_initializer_list

• recursive_initializer_list_t

• ref_array<T, 1> - 1-D Array reference specialization.

• ref_array - Array reference.

• repeat(const T &) - Repeats value N times.

• repeat(index_t, const T &) - Repeats value N times.

• sample(Dist &)

• sample(index_t, Dist &)

• seq(const index_t, const index_t, const distance_t)

• slice

• square(const T &)

• string - Standard string type.

• string_rule - Coercion rules for string type.

• sum(Iter, Sent, T) - Returns either the summation of the elements in a Range or in the sequence [first, last).

• sum(const Rng &, T) - Returns either the summation of the elements in a Range or in the sequence [first, last).

• sum_args()

• sum_args(const T &, Args &&…)

• to_column(base_column<C> &&)

• to_column(const base_column<C> &)

• to_vector(A &&)

• to_vector(Rng &&)

• to_vector(const base_column<C> &)

• to_view(base_column<C> &)

• to_view(const base_column<C> &&)

• to_view(const base_column<C> &)

• uinteger - Standard unsigned type.

• unary_expr_array

• uniform_index_sample(index_t)

• vector - (1) N-Dimensional array aliasing.

jules::blas

• cblas

• cblas<double>

• cblas<float>

• invalid

• product(const matrix<T> &, const matrix<T> &)

• safe_int_cast(T)

jules::debug

• default_module

• fatal_module_t

• throwing_module

• throwing_module_t

jules::debug::level - Debug level for each kind of checking.

• boundary_check

• extents_check

• invalid_argument

• invalid_state

• unreachable

jules::meta

• bool_constant

• compiles<T, Expression, void_t<Expression<T>>>

• compiles

• conjunction

• conjunction<B, Bs…>

• conjunction<B>

• fallback

• fallback_t

• negation

• requires

• requires_t

• void_t

jules::range

• using directive

ranges::v3::view

• interval(T, T, T)

• interval_n(T, T, ::jules::index_t)

• numbers(T, T)

• numbers_n(T, ::jules::index_t, T)