Classes | |
| class | auto_array |
| Like std::auto_ptr, but with delete[]. More... | |
| class | error |
| All scitbx exceptions are derived from this class. More... | |
| class | error_index |
| Special class for "Index out of range." exceptions. More... | |
| class | error_base |
| Exception which can plug into the SCITBX_ERROR_UTILS_ASSERT trickery. More... | |
| class | histogram |
| Histogram of an array of scalar values. More... | |
| struct | indexed_value |
| class | mat2 |
| Matrix class (2x2). More... | |
| class | mat3 |
| Matrix class (3x3). More... | |
| class | mat_grid |
| class | mat_const_ref |
| class | mat_ref |
| class | sym_mat2 |
| Symmetric 2x2 matrix class. More... | |
| class | sym_mat3 |
| Symmetric 3x3 matrix class. More... | |
| struct | type_holder |
| class | vec2 |
| Two-dimensional vector. More... | |
| class | vec3 |
| Three-dimensional vector. More... | |
Namespaces | |
| namespace | constants |
| General purpose mathematical or physical constants. | |
| namespace | fftpack |
| Fast Fourier Transformations based on FFTPACK. | |
| namespace | lbfgs |
| Limited-memory Broyden-Fletcher-Goldfarb-Shanno (LBFGS) minimizer. | |
| namespace | lbfgsb |
| C++ port of L-BFGS-B Version 2.1. | |
| namespace | math |
| Math utilities. | |
| namespace | minpack |
| C++ port of files in MINPACK. | |
| namespace | random |
| Easy access to Boost.Random. | |
Functions | |
| template<typename T> | |
| void | swap (auto_array< T > &a, auto_array< T > &b) |
| double | deg_as_rad (double deg) |
| Conversions from degrees to radians. | |
| double | rad_as_deg (double rad) |
| Conversions from radians to degrees. | |
| template<typename NumType> | |
| bool | operator== (mat2< NumType > const &lhs, mat2< NumType > const &rhs) |
| Test equality. | |
| template<typename NumType> | |
| bool | operator== (mat2< NumType > const &lhs, NumType const &rhs) |
| Test equality. True if all elements of lhs == rhs. | |
| template<typename NumType> | |
| bool | operator== (NumType const &lhs, mat2< NumType > const &rhs) |
| Test equality. True if all elements of rhs == lhs. | |
| template<typename NumType> | |
| bool | operator!= (mat2< NumType > const &lhs, mat2< NumType > const &rhs) |
| Test inequality. | |
| template<typename NumType> | |
| bool | operator!= (mat2< NumType > const &lhs, NumType const &rhs) |
| Test inequality. True if any element of lhs != rhs. | |
| template<typename NumType> | |
| bool | operator!= (NumType const &lhs, mat2< NumType > const &rhs) |
| Test inequality. True if any element of rhs != lhs. | |
| template<typename NumType> | |
| mat2< NumType > | operator+ (mat2< NumType > const &lhs, mat2< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| mat2< NumType > | operator+ (mat2< NumType > const &lhs, NumType const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| mat2< NumType > | operator+ (NumType const &lhs, mat2< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| mat2< NumType > | operator- (mat2< NumType > const &lhs, mat2< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| mat2< NumType > | operator- (mat2< NumType > const &lhs, NumType const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| mat2< NumType > | operator- (NumType const &lhs, mat2< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| mat2< typename af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic > | operator* (mat2< NumTypeLhs > const &lhs, mat2< NumTypeRhs > const &rhs) |
| Matrix * matrix product. | |
| template<typename NumTypeMatrix, typename NumTypeVector> | |
| vec2< typename af::binary_operator_traits < NumTypeMatrix, NumTypeVector > ::arithmetic > | operator* (mat2< NumTypeMatrix > const &lhs, af::tiny_plain< NumTypeVector, 2 > const &rhs) |
| Matrix * vector product. | |
| template<typename NumTypeVector, typename NumTypeMatrix> | |
| vec2< typename af::binary_operator_traits < NumTypeMatrix, NumTypeVector > ::arithmetic > | operator* (af::tiny_plain< NumTypeVector, 2 > const &lhs, mat2< NumTypeMatrix > const &rhs) |
| Vector * matrix product. | |
| template<typename NumType> | |
| mat2< NumType > | operator* (mat2< NumType > const &lhs, NumType const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| mat2< NumType > | operator* (NumType const &lhs, mat2< NumType > const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| mat2< NumType > | operator/ (mat2< NumType > const &lhs, NumType const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| mat2< NumType > | operator/ (NumType const &lhs, mat2< NumType > const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| mat2< NumType > | operator% (mat2< NumType > const &lhs, NumType const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| mat2< NumType > | operator% (NumType const &lhs, mat2< NumType > const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| mat2< NumType > & | operator+= (mat2< NumType > &lhs, mat2< NumType > const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| mat2< NumType > & | operator+= (mat2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| mat2< NumType > & | operator-= (mat2< NumType > &lhs, mat2< NumType > const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| mat2< NumType > & | operator-= (mat2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| mat2< NumType > & | operator*= (mat2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place multiplication. | |
| template<typename NumType> | |
| mat2< NumType > & | operator/= (mat2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place division. | |
| template<typename NumType> | |
| mat2< NumType > & | operator%= (mat2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place modulus operation. | |
| template<typename NumType> | |
| mat2< NumType > | operator- (mat2< NumType > const &v) |
| Element-wise unary minus. | |
| template<typename NumType> | |
| mat2< NumType > | operator+ (mat2< NumType > const &v) |
| Element-wise unary plus. | |
| template<typename NumType> | |
| bool | operator== (mat3< NumType > const &lhs, mat3< NumType > const &rhs) |
| Test equality. | |
| template<typename NumType> | |
| bool | operator== (mat3< NumType > const &lhs, NumType const &rhs) |
| Test equality. True if all elements of lhs == rhs. | |
| template<typename NumType> | |
| bool | operator== (NumType const &lhs, mat3< NumType > const &rhs) |
| Test equality. True if all elements of rhs == lhs. | |
| template<typename NumType> | |
| bool | operator!= (mat3< NumType > const &lhs, mat3< NumType > const &rhs) |
| Test inequality. | |
| template<typename NumType> | |
| bool | operator!= (mat3< NumType > const &lhs, NumType const &rhs) |
| Test inequality. True if any element of lhs != rhs. | |
| template<typename NumType> | |
| bool | operator!= (NumType const &lhs, mat3< NumType > const &rhs) |
| Test inequality. True if any element of rhs != lhs. | |
| template<typename NumType> | |
| mat3< NumType > | operator+ (mat3< NumType > const &lhs, mat3< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| mat3< NumType > | operator+ (mat3< NumType > const &lhs, NumType const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| mat3< NumType > | operator+ (NumType const &lhs, mat3< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| mat3< NumType > | operator- (mat3< NumType > const &lhs, mat3< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| mat3< NumType > | operator- (mat3< NumType > const &lhs, NumType const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| mat3< NumType > | operator- (NumType const &lhs, mat3< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| mat3< typename af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic > | operator* (mat3< NumTypeLhs > const &lhs, mat3< NumTypeRhs > const &rhs) |
| Matrix * matrix product. | |
| template<typename NumTypeMatrix, typename NumTypeVector> | |
| vec3< typename af::binary_operator_traits < NumTypeMatrix, NumTypeVector > ::arithmetic > | operator* (mat3< NumTypeMatrix > const &lhs, af::tiny_plain< NumTypeVector, 3 > const &rhs) |
| Matrix * vector product. | |
| template<typename NumTypeVector, typename NumTypeMatrix> | |
| vec3< typename af::binary_operator_traits < NumTypeMatrix, NumTypeVector > ::arithmetic > | operator* (af::tiny_plain< NumTypeVector, 3 > const &lhs, mat3< NumTypeMatrix > const &rhs) |
| Vector * matrix product. | |
| template<typename NumType> | |
| mat3< NumType > | operator* (mat3< NumType > const &lhs, NumType const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| mat3< NumType > | operator* (NumType const &lhs, mat3< NumType > const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| mat3< NumType > | operator/ (mat3< NumType > const &lhs, NumType const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| mat3< NumType > | operator/ (NumType const &lhs, mat3< NumType > const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| mat3< NumType > | operator% (mat3< NumType > const &lhs, NumType const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| mat3< NumType > | operator% (NumType const &lhs, mat3< NumType > const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| mat3< NumType > & | operator+= (mat3< NumType > &lhs, mat3< NumType > const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| mat3< NumType > & | operator+= (mat3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| mat3< NumType > & | operator-= (mat3< NumType > &lhs, mat3< NumType > const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| mat3< NumType > & | operator-= (mat3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| mat3< NumType > & | operator*= (mat3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place multiplication. | |
| template<typename NumType> | |
| mat3< NumType > & | operator/= (mat3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place division. | |
| template<typename NumType> | |
| mat3< NumType > & | operator%= (mat3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place modulus operation. | |
| template<typename NumType> | |
| mat3< NumType > | operator- (mat3< NumType > const &v) |
| Element-wise unary minus. | |
| template<typename NumType> | |
| mat3< NumType > | operator+ (mat3< NumType > const &v) |
| Element-wise unary plus. | |
| template<typename NumType, typename AccessorType> | |
| bool | operator== (mat_const_ref< NumType, AccessorType > const &lhs, mat_const_ref< NumType, AccessorType > const &rhs) |
| Tests equality. | |
| template<typename NumType, typename AccessorType> | |
| bool | operator== (mat_const_ref< NumType, AccessorType > const &lhs, NumType const &rhs) |
| Tests equality. True if all elements of lhs == rhs. | |
| template<typename NumType, typename AccessorType> | |
| bool | operator== (NumType const &lhs, mat_const_ref< NumType, AccessorType > const &rhs) |
| Test equality. True if all elements of rhs == lhs. | |
| template<typename NumType, typename AccessorType> | |
| bool | operator!= (mat_const_ref< NumType, AccessorType > const &lhs, mat_const_ref< NumType, AccessorType > const &rhs) |
| Test inequality. | |
| template<typename NumType, typename AccessorType> | |
| bool | operator!= (mat_const_ref< NumType, AccessorType > const &lhs, NumType const &rhs) |
| Test inequality. True if any element of lhs != rhs. | |
| template<typename NumType, typename AccessorType> | |
| bool | operator!= (NumType const &lhs, mat_const_ref< NumType, AccessorType > const &rhs) |
| Test inequality. True if any element of rhs != lhs. | |
| template<typename NumType, typename AccessorType> | |
| mat_ref< NumType, AccessorType > const & | operator+= (mat_ref< NumType, AccessorType > const &lhs, mat_const_ref< NumType, AccessorType > const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType, typename AccessorType> | |
| mat_ref< NumType, AccessorType > const & | operator+= (mat_ref< NumType, AccessorType > const &lhs, NumType const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType, typename AccessorType> | |
| mat_ref< NumType, AccessorType > const & | operator-= (mat_ref< NumType, AccessorType > const &lhs, mat_const_ref< NumType, AccessorType > const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType, typename AccessorType> | |
| mat_ref< NumType, AccessorType > const & | operator-= (mat_ref< NumType, AccessorType > const &lhs, NumType const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType, typename AccessorType> | |
| mat_ref< NumType, AccessorType > const & | operator*= (mat_ref< NumType, AccessorType > const &lhs, NumType const &rhs) |
| Element-wise in-place multiplication. | |
| template<typename NumType, typename AccessorType> | |
| mat_ref< NumType, AccessorType > const & | operator/= (mat_ref< NumType, AccessorType > const &lhs, NumType const &rhs) |
| Element-wise in-place division. | |
| template<typename NumType, typename AccessorType> | |
| mat_ref< NumType, AccessorType > const & | operator%= (mat_ref< NumType, AccessorType > const &lhs, NumType const &rhs) |
| Element-wise in-place modulus operation. | |
| template<typename NumTypeA, typename AccessorTypeA, typename NumTypeB, typename AccessorTypeB, typename NumTypeAB, typename AccessorTypeAB> | |
| void | multiply (mat_const_ref< NumTypeA, AccessorTypeA > const &a, mat_const_ref< NumTypeB, AccessorTypeB > const &b, mat_ref< NumTypeAB, AccessorTypeAB > const &ab) |
| Matrix multiplication. | |
| template<typename IndexType, typename SizeType> | |
| SizeType | positive_getitem_index (IndexType const &i, SizeType const &size, bool allow_i_eq_size=false, const char *index_out_of_range="Index out of range.") |
| template<typename IntType> | |
| std::string | format (boost::rational< IntType > const &v, bool decimal=false) |
| Formatting of rational numbers. | |
| template<typename ArrayType> | |
| ArrayType::value_type | array_lcm (ArrayType const &a) |
| template<typename ElementType> | |
| std::ostream & | operator<< (std::ostream &o, std::vector< ElementType > const &a) |
| template<typename NumType> | |
| bool | operator== (sym_mat2< NumType > const &lhs, sym_mat2< NumType > const &rhs) |
| Test equality. | |
| template<typename NumType> | |
| bool | operator== (sym_mat2< NumType > const &lhs, NumType const &rhs) |
| Test equality. True if all elements of lhs == rhs. | |
| template<typename NumType> | |
| bool | operator== (NumType const &lhs, sym_mat2< NumType > const &rhs) |
| Test equality. True if all elements of rhs == lhs. | |
| template<typename NumType> | |
| bool | operator!= (sym_mat2< NumType > const &lhs, sym_mat2< NumType > const &rhs) |
| Test inequality. | |
| template<typename NumType> | |
| bool | operator!= (sym_mat2< NumType > const &lhs, NumType const &rhs) |
| Test inequality. True if any element of lhs != rhs. | |
| template<typename NumType> | |
| bool | operator!= (NumType const &lhs, sym_mat2< NumType > const &rhs) |
| Test inequality. True if any element of rhs != lhs. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator+ (sym_mat2< NumType > const &lhs, sym_mat2< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator+ (sym_mat2< NumType > const &lhs, NumType const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator+ (NumType const &lhs, sym_mat2< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator- (sym_mat2< NumType > const &lhs, sym_mat2< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator- (sym_mat2< NumType > const &lhs, NumType const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator- (NumType const &lhs, sym_mat2< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| mat2< typename af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic > | operator* (sym_mat2< NumTypeLhs > const &lhs, sym_mat2< NumTypeRhs > const &rhs) |
| Symmetric * symmetric matrix product. | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| mat2< typename af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic > | operator* (mat2< NumTypeLhs > const &lhs, sym_mat2< NumTypeRhs > const &rhs) |
| Square * symmetric matrix product. | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| mat2< typename af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic > | operator* (sym_mat2< NumTypeLhs > const &lhs, mat2< NumTypeRhs > const &rhs) |
| Symmetric * square matrix product. | |
| template<typename NumTypeMatrix, typename NumTypeVector> | |
| vec2< typename af::binary_operator_traits < NumTypeMatrix, NumTypeVector > ::arithmetic > | operator* (sym_mat2< NumTypeMatrix > const &lhs, af::tiny_plain< NumTypeVector, 2 > const &rhs) |
| Matrix * vector product. | |
| template<typename NumTypeVector, typename NumTypeMatrix> | |
| vec2< typename af::binary_operator_traits < NumTypeMatrix, NumTypeVector > ::arithmetic > | operator* (af::tiny_plain< NumTypeVector, 2 > const &lhs, sym_mat2< NumTypeMatrix > const &rhs) |
| Vector * matrix product. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator* (sym_mat2< NumType > const &lhs, NumType const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator* (NumType const &lhs, sym_mat2< NumType > const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator/ (sym_mat2< NumType > const &lhs, NumType const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator/ (NumType const &lhs, sym_mat2< NumType > const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator% (sym_mat2< NumType > const &lhs, NumType const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator% (NumType const &lhs, sym_mat2< NumType > const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| sym_mat2< NumType > & | operator+= (sym_mat2< NumType > &lhs, sym_mat2< NumType > const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| sym_mat2< NumType > & | operator+= (sym_mat2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| sym_mat2< NumType > & | operator-= (sym_mat2< NumType > &lhs, sym_mat2< NumType > const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| sym_mat2< NumType > & | operator-= (sym_mat2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| sym_mat2< NumType > & | operator*= (sym_mat2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place multiplication. | |
| template<typename NumType> | |
| sym_mat2< NumType > & | operator/= (sym_mat2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place division. | |
| template<typename NumType> | |
| sym_mat2< NumType > & | operator%= (sym_mat2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place modulus operation. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator- (sym_mat2< NumType > const &v) |
| Element-wise unary minus. | |
| template<typename NumType> | |
| sym_mat2< NumType > | operator+ (sym_mat2< NumType > const &v) |
| Element-wise unary plus. | |
| template<typename NumType> | |
| bool | operator== (sym_mat3< NumType > const &lhs, sym_mat3< NumType > const &rhs) |
| Test equality. | |
| template<typename NumType> | |
| bool | operator== (sym_mat3< NumType > const &lhs, NumType const &rhs) |
| Test equality. True if all elements of lhs == rhs. | |
| template<typename NumType> | |
| bool | operator== (NumType const &lhs, sym_mat3< NumType > const &rhs) |
| Test equality. True if all elements of rhs == lhs. | |
| template<typename NumType> | |
| bool | operator!= (sym_mat3< NumType > const &lhs, sym_mat3< NumType > const &rhs) |
| Test inequality. | |
| template<typename NumType> | |
| bool | operator!= (sym_mat3< NumType > const &lhs, NumType const &rhs) |
| Test inequality. True if any element of lhs != rhs. | |
| template<typename NumType> | |
| bool | operator!= (NumType const &lhs, sym_mat3< NumType > const &rhs) |
| Test inequality. True if any element of rhs != lhs. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator+ (sym_mat3< NumType > const &lhs, sym_mat3< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator+ (sym_mat3< NumType > const &lhs, NumType const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator+ (NumType const &lhs, sym_mat3< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator- (sym_mat3< NumType > const &lhs, sym_mat3< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator- (sym_mat3< NumType > const &lhs, NumType const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator- (NumType const &lhs, sym_mat3< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| mat3< typename af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic > | operator* (sym_mat3< NumTypeLhs > const &lhs, sym_mat3< NumTypeRhs > const &rhs) |
| Symmetric * symmetric matrix product. | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| mat3< typename af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic > | operator* (mat3< NumTypeLhs > const &lhs, sym_mat3< NumTypeRhs > const &rhs) |
| Square * symmetric matrix product. | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| mat3< typename af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic > | operator* (sym_mat3< NumTypeLhs > const &lhs, mat3< NumTypeRhs > const &rhs) |
| Symmetric * square matrix product. | |
| template<typename NumTypeMatrix, typename NumTypeVector> | |
| vec3< typename af::binary_operator_traits < NumTypeMatrix, NumTypeVector > ::arithmetic > | operator* (sym_mat3< NumTypeMatrix > const &lhs, af::tiny_plain< NumTypeVector, 3 > const &rhs) |
| Matrix * vector product. | |
| template<typename NumTypeVector, typename NumTypeMatrix> | |
| vec3< typename af::binary_operator_traits < NumTypeMatrix, NumTypeVector > ::arithmetic > | operator* (af::tiny_plain< NumTypeVector, 3 > const &lhs, sym_mat3< NumTypeMatrix > const &rhs) |
| Vector * matrix product. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator* (sym_mat3< NumType > const &lhs, NumType const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator* (NumType const &lhs, sym_mat3< NumType > const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator/ (sym_mat3< NumType > const &lhs, NumType const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator/ (NumType const &lhs, sym_mat3< NumType > const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator% (sym_mat3< NumType > const &lhs, NumType const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator% (NumType const &lhs, sym_mat3< NumType > const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| sym_mat3< NumType > & | operator+= (sym_mat3< NumType > &lhs, sym_mat3< NumType > const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| sym_mat3< NumType > & | operator+= (sym_mat3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| sym_mat3< NumType > & | operator-= (sym_mat3< NumType > &lhs, sym_mat3< NumType > const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| sym_mat3< NumType > & | operator-= (sym_mat3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| sym_mat3< NumType > & | operator*= (sym_mat3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place multiplication. | |
| template<typename NumType> | |
| sym_mat3< NumType > & | operator/= (sym_mat3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place division. | |
| template<typename NumType> | |
| sym_mat3< NumType > & | operator%= (sym_mat3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place modulus operation. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator- (sym_mat3< NumType > const &v) |
| Element-wise unary minus. | |
| template<typename NumType> | |
| sym_mat3< NumType > | operator+ (sym_mat3< NumType > const &v) |
| Element-wise unary plus. | |