scitbx Namespace Reference

Conversion of versa<T, scitbx::matrix::packed_[ul]_accessor> to flex array. More...


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...
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 IntType>
std::string format (boost::rational< IntType > const *values, std::size_t values_size, char const *seperator=",", bool decimal=false)
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 NumTypeVector, typename NumTypeMatrix>
af::binary_operator_traits
< NumTypeVector, NumTypeMatrix >
::arithmetic 
operator* (af::tiny_plain< NumTypeVector, 6 > const &form, sym_mat3< NumTypeMatrix > const &matrix_as_vec6)
 Linear form * (matrix as 6-vector).
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.


Detailed Description

Conversion of versa<T, scitbx::matrix::packed_[ul]_accessor> to flex array.

Eigenvalues and eigenvectors computation.

Tools implementing the Gauss-Newton method for non-linear least-squares.

Common scitbx namespace.

Conversions flattening and unflattening e.g. shared< tiny<T,N> >.

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.

Extension of boost::math statistical distributions. See also: http://www.boost.org/libs/math/doc/sf_and_dist/html/math_toolkit/dist.html


Generated on Thu Jun 19 15:35:08 2014 for cctbx by  doxygen 1.5.6