Classes | |
| class | auto_array |
| Like std::auto_ptr, but with delete[]. More... | |
| struct | cubicles |
| 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 | optional_copy |
| Optional allocation of value with new, with value-copy semantics. More... | |
| struct | rotr3 |
| 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. | |
| namespace | rigid_body |
| Rigid-body algorithms (main reference: see essence/featherstone.py). | |
Typedefs | |
| typedef boost::rational< int > | rational_int |
| typedef scitbx::vec3< signed char > | tiny3 |
| typedef scitbx::vec3< int > | int3 |
| typedef scitbx::vec3< long > | long3 |
| typedef scitbx::vec3< double > | double3 |
|
typedef scitbx::vec3 < rational_int > | rational_int3 |
Functions | |
| template<typename IntType> | |
| IntType | ceil (const boost::rational< IntType > &r) |
| template<typename IntType> | |
| IntType | floor (const boost::rational< IntType > &r) |
| template<typename IntType> | |
| IntType | iround (const boost::rational< IntType > &r) |
| template<typename IntType> | |
| bool | operator<= (const double lhs, const boost::rational< IntType > &rhs) |
| template<typename IntType> | |
| bool | operator>= (const double lhs, const boost::rational< IntType > &rhs) |
| template<typename ReturnType, typename InputType> | |
| scitbx::vec3< ReturnType > | vec3_cast (const scitbx::vec3< InputType > &i) |
| template<typename FloatType> | |
| scitbx::vec3< FloatType > | floor (const scitbx::vec3< FloatType > &v) |
| template<typename FloatType> | |
| scitbx::vec3< FloatType > | round (const scitbx::vec3< FloatType > &v) |
| template<typename IntType> | |
| scitbx::vec3< IntType > | ceil (const scitbx::vec3< boost::rational< IntType > > &rv) |
| template<typename IntType> | |
| scitbx::vec3< IntType > | floor (const scitbx::vec3< boost::rational< IntType > > &r) |
| template<typename IntType> | |
| scitbx::vec3< IntType > | iround (const scitbx::vec3< boost::rational< IntType > > &r) |
| template<typename LhsNumType, typename RhsNumType> | |
| bool | le_all (const scitbx::vec3< LhsNumType > &lhs, const scitbx::vec3< RhsNumType > &rhs) |
| template<typename LhsNumType, typename RhsNumType> | |
| bool | lt_all (const scitbx::vec3< LhsNumType > &lhs, const scitbx::vec3< RhsNumType > &rhs) |
| template<typename LhsNumType, typename RhsNumType> | |
| bool | ge_all (const scitbx::vec3< LhsNumType > &lhs, const scitbx::vec3< RhsNumType > &rhs) |
| template<typename LhsNumType, typename RhsNumType> | |
| bool | gt_all (const scitbx::vec3< LhsNumType > &lhs, const scitbx::vec3< RhsNumType > &rhs) |
| template<typename LhsNumType, typename RhsNumType> | |
| bool | eq_all (const scitbx::vec3< LhsNumType > &lhs, const scitbx::vec3< RhsNumType > &rhs) |
| template<typename LhsNumType, typename RhsNumType> | |
| scitbx::vec3< LhsNumType > & | operator+= (scitbx::vec3< LhsNumType > &lhs, const scitbx::vec3< RhsNumType > &rhs) |
| template<typename LhsNumType, typename RhsNumType> | |
| scitbx::vec3< LhsNumType > | operator+ (const scitbx::vec3< LhsNumType > &lhs, const scitbx::vec3< RhsNumType > &rhs) |
| template<typename LhsNumType, typename RhsNumType> | |
| scitbx::vec3< LhsNumType > & | operator-= (scitbx::vec3< LhsNumType > &lhs, const scitbx::vec3< RhsNumType > &rhs) |
| template<typename LhsType, typename RhsType> | |
| void | mul (scitbx::vec3< LhsType > &lhs, const scitbx::vec3< RhsType > &rhs) |
| template<typename NumType> | |
| std::ostream & | out (std::ostream &os, const scitbx::vec3< NumType > &v) |
| template<typename NumType> | |
| std::ostream & | operator<< (std::ostream &os, const scitbx::vec3< NumType > &v) |
| 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. | |
| void | cubicles_max_memory_allocation_set (unsigned long number_of_bytes) |
| unsigned long | cubicles_max_memory_allocation_get () |
| 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 NumTypeLhs, typename NumTypeRhs> | |
| mat3< typename af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic > | transpose_mul (mat3< NumTypeLhs > const &lhs, mat3< NumTypeRhs > const &rhs) |
| lhs.transpose() * rhs | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| mat3< typename af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic > | mul_transpose (mat3< NumTypeLhs > const &lhs, mat3< NumTypeRhs > const &rhs) |
| lhs * rhs.transpose() | |
| 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 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. | |
| template<typename NumType> | |
| bool | operator== (vec2< NumType > const &lhs, vec2< NumType > const &rhs) |
| Test equality. | |
| template<typename NumType> | |
| bool | operator== (vec2< NumType > const &lhs, NumType const &rhs) |
| Test equality. True if all elements of lhs == rhs. | |
| template<typename NumType> | |
| bool | operator== (NumType const &lhs, vec2< NumType > const &rhs) |
| Test equality. True if all elements of rhs == lhs. | |
| template<typename NumType> | |
| bool | operator!= (vec2< NumType > const &lhs, vec2< NumType > const &rhs) |
| Test inequality. | |
| template<typename NumType> | |
| bool | operator!= (vec2< NumType > const &lhs, NumType const &rhs) |
| Test inequality. True if any element of lhs != rhs. | |
| template<typename NumType> | |
| bool | operator!= (NumType const &lhs, vec2< NumType > const &rhs) |
| Test inequality. True if any element of rhs != lhs. | |
| template<typename NumType> | |
| vec2< NumType > | operator+ (vec2< NumType > const &lhs, vec2< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| vec2< NumType > | operator+ (vec2< NumType > const &lhs, NumType const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| vec2< NumType > | operator+ (NumType const &lhs, vec2< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| vec2< NumType > | operator- (vec2< NumType > const &lhs, vec2< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| vec2< NumType > | operator- (vec2< NumType > const &lhs, NumType const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| vec2< NumType > | operator- (NumType const &lhs, vec2< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic | operator* (vec2< NumTypeLhs > const &lhs, vec2< NumTypeRhs > const &rhs) |
| Dot product. | |
| template<typename NumType> | |
| vec2< NumType > | operator* (vec2< NumType > const &lhs, NumType const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| vec2< NumType > | operator* (NumType const &lhs, vec2< NumType > const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| vec2< NumType > | operator/ (vec2< NumType > const &lhs, NumType const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| vec2< NumType > | operator/ (vec2< NumType > const &lhs, std::size_t const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| vec2< NumType > | operator/ (NumType const &lhs, vec2< NumType > const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| vec2< NumType > | operator% (vec2< NumType > const &lhs, NumType const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| vec2< NumType > | operator% (NumType const &lhs, vec2< NumType > const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| vec2< NumType > & | operator+= (vec2< NumType > &lhs, vec2< NumType > const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| vec2< NumType > & | operator+= (vec2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| vec2< NumType > & | operator-= (vec2< NumType > &lhs, vec2< NumType > const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| vec2< NumType > & | operator-= (vec2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| vec2< NumType > & | operator*= (vec2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place multiplication. | |
| template<typename NumType> | |
| vec2< NumType > & | operator/= (vec2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place division. | |
| template<typename NumType> | |
| vec2< NumType > & | operator%= (vec2< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place modulus operation. | |
| template<typename NumType> | |
| vec2< NumType > | operator- (vec2< NumType > const &v) |
| Element-wise unary minus. | |
| template<typename NumType> | |
| vec2< NumType > | operator+ (vec2< NumType > const &v) |
| Element-wise unary plus. | |
| template<typename NumType> | |
| NumType | abs (vec2< NumType > const &v) |
| Return the length of the vector. | |
| template<typename NumType> | |
| bool | operator== (vec3< NumType > const &lhs, vec3< NumType > const &rhs) |
| Test equality. | |
| template<typename NumType> | |
| bool | operator== (vec3< NumType > const &lhs, NumType const &rhs) |
| Test equality. True if all elements of lhs == rhs. | |
| template<typename NumType> | |
| bool | operator== (NumType const &lhs, vec3< NumType > const &rhs) |
| Test equality. True if all elements of rhs == lhs. | |
| template<typename NumType> | |
| bool | operator!= (vec3< NumType > const &lhs, vec3< NumType > const &rhs) |
| Test inequality. | |
| template<typename NumType> | |
| bool | operator!= (vec3< NumType > const &lhs, NumType const &rhs) |
| Test inequality. True if any element of lhs != rhs. | |
| template<typename NumType> | |
| bool | operator!= (NumType const &lhs, vec3< NumType > const &rhs) |
| Test inequality. True if any element of rhs != lhs. | |
| template<typename NumType> | |
| vec3< NumType > | operator+ (vec3< NumType > const &lhs, vec3< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| vec3< NumType > | operator+ (vec3< NumType > const &lhs, NumType const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| vec3< NumType > | operator+ (NumType const &lhs, vec3< NumType > const &rhs) |
| Element-wise addition. | |
| template<typename NumType> | |
| vec3< NumType > | operator- (vec3< NumType > const &lhs, vec3< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| vec3< NumType > | operator- (vec3< NumType > const &lhs, NumType const &rhs) |
| Element-wise difference. | |
| template<typename NumType> | |
| vec3< NumType > | operator- (NumType const &lhs, vec3< NumType > const &rhs) |
| Element-wise difference. | |
| template<typename NumTypeLhs, typename NumTypeRhs> | |
| af::binary_operator_traits < NumTypeLhs, NumTypeRhs > ::arithmetic | operator* (vec3< NumTypeLhs > const &lhs, vec3< NumTypeRhs > const &rhs) |
| Dot product. | |
| template<typename NumType> | |
| vec3< NumType > | operator* (vec3< NumType > const &lhs, NumType const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| vec3< NumType > | operator* (NumType const &lhs, vec3< NumType > const &rhs) |
| Element-wise multiplication. | |
| template<typename NumType> | |
| vec3< NumType > | operator/ (vec3< NumType > const &lhs, vec3< NumType > const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| vec3< NumType > | operator/ (vec3< NumType > const &lhs, NumType const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| vec3< NumType > | operator/ (vec3< NumType > const &lhs, std::size_t const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| vec3< NumType > | operator/ (NumType const &lhs, vec3< NumType > const &rhs) |
| Element-wise division. | |
| template<typename NumType> | |
| vec3< NumType > | operator% (vec3< NumType > const &lhs, NumType const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| vec3< NumType > | operator% (NumType const &lhs, vec3< NumType > const &rhs) |
| Element-wise modulus operation. | |
| template<typename NumType> | |
| vec3< NumType > & | operator+= (vec3< NumType > &lhs, vec3< NumType > const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| vec3< NumType > & | operator+= (vec3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place addition. | |
| template<typename NumType> | |
| vec3< NumType > & | operator-= (vec3< NumType > &lhs, vec3< NumType > const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| vec3< NumType > & | operator-= (vec3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place difference. | |
| template<typename NumType> | |
| vec3< NumType > & | operator*= (vec3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place multiplication. | |
| template<typename NumType> | |
| vec3< NumType > & | operator/= (vec3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place division. | |
| template<typename NumType> | |
| vec3< NumType > & | operator%= (vec3< NumType > &lhs, NumType const &rhs) |
| Element-wise in-place modulus operation. | |
| template<typename NumType> | |
| vec3< NumType > | operator- (vec3< NumType > const &v) |
| Element-wise unary minus. | |
| template<typename NumType> | |
| vec3< NumType > | operator+ (vec3< NumType > const &v) |
| Element-wise unary plus. | |
| template<typename NumType> | |
| NumType | abs (vec3< NumType > const &v) |
| Return the length of the vector. | |
Eigenvalues and eigenvectors computation.
Tools implementing the Gauss-Newton method for non-linear least-squares.
Convertion of the owning references defined in scitbx/array_family/owning_ref.h to Python
Matrix related functions operating on af::ref and af::const_ref.
1.5.6