---

more::math Namespace Reference

Mathematical types and functions. More...

Compounds

• struct more::math::alpha_tag
• struct more::math::balanced_type_
• struct more::math::beta_tag
• class more::math::closed_interval

  A continuous interval which contains both extremums. More...
  
  

• struct more::math::coalpha_tag
• struct more::math::cobeta_tag
• struct more::math::cospinor
• struct more::math::divides_type_
• struct more::math::element_type_
• struct more::math::element_type_< num::vectin< T, N > >
• struct more::math::half_tag
• struct more::math::halfint
• class more::math::hash

  A hash of minimum Width number of bits. More...
  
  

• class more::math::interval

  A continuous interval. More...
  
  

• class more::math::interval_base

  Helper for interval classes. More...
  
  

• class more::math::left_interval

  A continuous interval which contains its infimum but not its supremum. More...
  
  

• struct more::math::minus_half_tag
• struct more::math::minus_one_tag
• struct more::math::minus_onei_tag
• struct more::math::minus_type_
• struct more::math::norm_type_
• struct more::math::norm_type_< alpha_tag >
• struct more::math::norm_type_< beta_tag >
• struct more::math::norm_type_< coalpha_tag >
• struct more::math::norm_type_< cobeta_tag >
• struct more::math::norm_type_< complex< T > >
• struct more::math::norm_type_< const T >
• struct more::math::norm_type_< num::vectin< T, N > >
• struct more::math::norm_type_< spinopr< T > >
• struct more::math::norm_type_< spinor< T > >
• struct more::math::one_tag
• struct more::math::onei_tag
• class more::math::open_internal

  A continuous interval which does not contain its extremums. More...
  
  

• struct more::math::open_interval
• struct more::math::outer_product_type_
• struct more::math::outer_product_type_< complex< T > >
• struct more::math::outer_product_type_< const T >
• struct more::math::outer_product_type_< double >
• struct more::math::outer_product_type_< float >
• struct more::math::outer_product_type_< int >
• struct more::math::outer_product_type_< long double >
• struct more::math::outer_product_type_< spinor< T > >
• struct more::math::plus_type_
• struct more::math::pm_half
• class more::math::pm_one
• struct more::math::position_type_
• class more::math::right_interval

  A continuous interval which contains its supremum but not its infimum. More...
  
  

• struct more::math::scalar_type_
• struct more::math::scalar_type_< complex< T > >
• struct more::math::scalar_type_< const T >
• struct more::math::scalar_type_< double >
• struct more::math::scalar_type_< float >
• struct more::math::scalar_type_< int >
• struct more::math::scalar_type_< long double >
• struct more::math::scalar_type_< num::vectin< T, N > >
• struct more::math::scalar_type_< spinopr< T > >
• struct more::math::scalar_type_< spinor< T > >
• struct more::math::sigma_x_tag
• struct more::math::sigma_y_tag
• struct more::math::sigma_z_tag
• struct more::math::size_
• struct more::math::spinopr
• struct more::math::spinor
• struct more::math::times_type_
• struct more::math::undefined_type
• struct more::math::zero_tag

Functions

• minus_onei_tag operator- (onei_tag)
• onei_tag operator- (minus_onei_tag)
• template<typename T> complex< T > operator * (const complex< T > &x, onei_tag)
• template<typename T> complex< T > operator * (onei_tag, const complex< T > &y)
• template<typename T> complex< T > operator * (const complex< T > &x, minus_onei_tag)
• template<typename T> complex< T > operator * (minus_onei_tag, const complex< T > &y)
• complex< float > operator * (float x, onei_tag)
• complex< double > operator * (double x, onei_tag)
• complex< long double > operator * (long double x, onei_tag)
• complex< float > operator * (float x, minus_onei_tag)
• complex< double > operator * (double x, minus_onei_tag)
• complex< long double > operator * (long double x, minus_onei_tag)
• complex< float > operator * (onei_tag, float x)
• complex< double > operator * (onei_tag, double x)
• complex< long double > operator * (onei_tag, long double x)
• complex< float > operator * (minus_onei_tag, float x)
• complex< double > operator * (minus_onei_tag, double x)
• complex< long double > operator * (minus_onei_tag, long double x)
• template<typename T> int rank (complex< T > const &)
• template<typename T> int size0 (complex< T > const &)
• template<typename T> int size1 (complex< T > const &)
• template<typename T> int size2 (complex< T > const &)
• template<typename T> complex< T > trace (complex< T > const &x)
• template<typename T> complex< T > adj (complex< T > const &x)
• float adj (float x)
• double adj (double x)
• long double adj (long double x)
• complex< float > dot (complex< float > const &x, complex< float > const &y)
• complex< double > dot (complex< double > const &x, complex< double > const &y)
• complex< long double > dot (complex< long double > const &x, complex< long double > const &y)
• template<typename T> int finite (complex< T > const &x)
• template<typename T> cospinor< T > operator * (T x, coalpha_tag)
• template<typename T> T operator * (coalpha_tag, const spinor< T > &x)
• template<typename T> T operator * (const cospinor< T > &x, alpha_tag)
• template<typename T> T operator * (const cospinor< T > &x, beta_tag)
• template<typename T> cospinor< T > operator+ (const cospinor< T > &x)
• template<typename T> cospinor< T > operator- (const cospinor< T > &x)
• template<typename T, typename U> cospinor< typename plus_type_<
  T, U >::eval > operator+ (const cospinor< T > &x, const cospinor< U > &y)
• template<typename T, typename U> cospinor< typename minus_type_<
  T, U >::eval > operator- (const cospinor< T > &x, const cospinor< U > &y)
• template<typename T, typename U> cospinor< typename times_type_<
  T, U >::eval > operator * (const cospinor< T > &x, U y)
• template<typename T, typename U> cospinor< typename times_type_<
  T, U >::eval > operator * (T x, const cospinor< U > &y)
• template<typename T, typename U> cospinor< typename divides_type_<
  T, U >::eval > operator/ (const cospinor< T > &x, U y)
• template<typename T, typename U> times_type_< T, U >::eval operator * (const cospinor< T > &x, const spinor< U > &y)
• template<typename T, typename U> spinopr< typename times_type_<
  T, U >::eval > operator * (const spinor< T > &x, const cospinor< U > &y)
• template<typename T> cospinor< T > operator * (const cospinor< T > &x, const spinopr< T > &y)
• template<typename T> std::ostream & operator<< (std::ostream &, const cospinor< T > &)
• template<typename T> std::istream & operator>> (std::istream &, cospinor< T > &)
• template<typename T> norm_type_< T >::eval norm (const cospinor< T > &x)
• template<typename T> norm_type_< T >::eval abs (const cospinor< T > &x)
• template<typename T> T real_dot (const cospinor< std::complex< T > > &x, const cospinor< std::complex< T > > &y)
• template<typename T> cospinor< T > adj (const spinor< T > &x)
• template<typename T> spinor< T > adj (const cospinor< T > &x)
• template<typename T> T sum (const cospinor< T > &x)
• template<typename T> bool finite (const cospinor< T > &x)
• char encode_alpha (unsigned int k)

  Encode an integer in the range [0.. More...
  
  

• unsigned char decode_alpha (char ch)

  Decode an integer encoded with encode_alpha. More...
  
  

• char encode_alnum (unsigned int k)

  Encode an integer in the range [0..62) as an alphanumeric ASCII character. More...
  
  

• unsigned char decode_alnum (char ch)

  Decode an integer encoded with encode_alnum. More...
  
  

• lang::uint_least32_t hash_id32 (char ch0=0, char ch1=0, char ch2=0, char ch3=0, char ch4=0, char ch5=0)

  Returns a 32 bits encoding of 6 lower case characters. More...
  
  

• void encode64_alnum (lang::uint_least64_t, char *s)

  Encodes a 64 bits numbers into 1 ASCII alphabetic followed by 10 ASCII alphanumeric characters. More...
  
  

• lang::uint_least64_t decode64_alnum (char const *s)

  Decodes a 64 bits number encoded with encode64_alnum. More...
  
  

• template<unsigned int Width> std::ostream & operator<< (std::ostream &os, hash< Width > const &h)
• template<typename T> T length (interval_base< T > const &I)
• template<typename T> T center (interval_base< T > const &I)
• template<typename T, typename Less> interval< T, Less > make_interval (T const &x, bool lt, T const &y, bool rt, Less less=std::less< T >())
• template<typename T> interval< T > make_interval (T const &x, bool lt, T const &y, bool rt)
• double besjr (int, double)
• double besIr (double, double)
• double besir (int, double)
• double lagLc (int, int)
• int finite (double x)
• template<typename T> T max (T const &x, T const &y)
• template<typename T> T min (T const &x, T const &y)
• template<typename T> T abs (T const &x)
• long lround (double x)
• int iround (double x)
• long lfloor (double x)
• long lceil (double x)
• long ltrunc (double x)
• int ifloor (double x)
• int iceil (double x)
• int itrunc (double x)
• float real (float x)
• double real (double x)
• long double real (long double x)
• float imag (float x)
• double imag (double x)
• long double imag (long double x)
• template<typename T> T pow2 (const T &x)
• template<typename T> T pow3 (const T &x)
• template<typename T> T pow4 (const T &x)
• template<typename T> T pow5 (const T &x)
• template<typename T> T pow6 (const T &x)
• template<typename T> T pow7 (const T &x)
• template<typename T> T pow8 (const T &x)
• template<typename T> T pow9 (const T &x)
• template<typename T> T pow10 (const T &x)
• float conj (float x)
• double conj (double x)
• long double conj (long double x)
• unsigned int norm (unsigned int x)
• int norm (int x)
• float norm (float x)
• double norm (double x)
• long double norm (long double x)
• int ldexp (int x, int n)
• int ldexp (long x, int n)
• unsigned int ldexp (unsigned int x, int n)
• unsigned long ldexp (unsigned long x, int n)
• int rank (float)
• int rank (double)
• int rank (long double)
• int size0 (float)
• int size0 (double)
• int size0 (long double)
• int size1 (float)
• int size1 (double)
• int size1 (long double)
• int size2 (float)
• int size2 (double)
• int size2 (long double)
• template<typename T> int rank (T const &x)
• template<typename T> int size0 (T const &x)
• template<typename T> int size1 (T const &x)
• template<typename T> int size2 (T const &x)
• template<typename T> T trace (T const &x)
• float dot (float x, float y)
• double dot (double x, double y)
• long double dot (long double x, long double y)
• template<typename T> T subscript (T const &x, int i, int j=0, int k=0)
• template<typename T> T & subscript (T &x, int i, int j=0, int k=0)
• int factorial (int n, int m=0)
• int double_factorial (int n, int m=0)
• int binominal (int n, int i)
• unsigned int bitpow (unsigned int, int)
• float bitpow (float, int)
• double bitpow (double, int)
• long double bitpow (long double, int)
• int upper_bit (unsigned int)
• int lower_bit (unsigned int)
• one_tag operator+ (one_tag)
• minus_one_tag operator+ (minus_one_tag)
• template<typename T> zero_tag operator * (zero_tag, T)
• template<typename T> zero_tag operator * (T, zero_tag)
• template<typename T> zero_tag operator/ (zero_tag, T)
• template<typename T> T operator+ (zero_tag, const T &x)
• template<typename T> T operator+ (const T &x, zero_tag)
• template<typename T> T operator- (zero_tag, const T &x)
• template<typename T> T operator- (const T &x, zero_tag)
• template<typename T> T operator * (one_tag, const T &x)
• template<typename T> T operator * (const T &x, one_tag)
• template<typename T> T operator/ (const T &x, one_tag)
• template<typename T> T operator * (minus_one_tag, const T &x)
• template<typename T> T operator * (const T &x, minus_one_tag)
• template<typename T> T operator/ (const T &x, minus_one_tag)
• double sixj_2j (int, int, int, int, int, int)
• double ninej_2j (int, int, int, int, int, int, int, int, int)
• double clebsch_2j (int, int, int, int, int, int)
• double threejm_2j (int, int, int, int, int, int)
• minus_half_tag operator- (half_tag)
• half_tag operator+ (half_tag)
• bool operator== (half_tag x, pm_half y)
• bool operator== (minus_half_tag x, pm_half y)
• bool operator!= (pm_half x, pm_half y)
• bool operator!= (pm_half x, half_tag y)
• bool operator!= (pm_half x, minus_half_tag y)
• bool operator!= (half_tag x, pm_half y)
• bool operator!= (minus_half_tag x, pm_half y)
• int operator+ (half_tag, pm_half x)
• int operator+ (pm_half x, half_tag)
• int operator+ (minus_half_tag, pm_half x)
• int operator+ (pm_half x, minus_half_tag)
• int operator+ (pm_half x, pm_half y)
• int operator- (half_tag, pm_half x)
• int operator- (pm_half x, half_tag)
• int operator- (minus_half_tag, pm_half x)
• int operator- (pm_half x, minus_half_tag)
• int operator- (pm_half x, pm_half y)
• float operator * (pm_half x, float y)
• double operator * (pm_half x, double y)
• long double operator * (pm_half x, long double y)
• float operator * (float x, pm_half y)
• double operator * (double x, pm_half y)
• long double operator * (long double x, pm_half y)
• int enumerator (half_tag)
• int enumerator (minus_half_tag)
• int enumerator (pm_half x)
• std::istream & operator>> (std::istream &, pm_half &)
• std::ostream & operator<< (std::ostream &, pm_half)
• halfint operator * (int x, half_tag)
• halfint operator * (half_tag, int y)
• halfint operator * (int x, minus_half_tag)
• halfint operator * (minus_half_tag, int y)
• halfint operator+ (halfint x, half_tag)
• halfint operator+ (half_tag, halfint x)
• halfint operator- (halfint x, half_tag)
• halfint operator- (half_tag, halfint x)
• halfint operator+ (halfint x, minus_half_tag)
• halfint operator+ (minus_half_tag, halfint x)
• halfint operator- (halfint x, minus_half_tag)
• halfint operator- (minus_half_tag, halfint x)
• halfint operator+ (int x, half_tag)
• halfint operator+ (half_tag, int x)
• halfint operator- (int x, half_tag)
• halfint operator- (half_tag, int x)
• halfint operator+ (int x, minus_half_tag)
• halfint operator+ (minus_half_tag, int x)
• halfint operator- (int x, minus_half_tag)
• halfint operator- (minus_half_tag, int x)
• float operator * (float x, half_tag)
• float operator * (half_tag, float y)
• double operator * (double x, half_tag)
• double operator * (half_tag, double y)
• long double operator * (long double x, half_tag)
• long double operator * (half_tag, long double y)
• halfint operator+ (halfint x, halfint y)
• halfint operator- (halfint x, halfint y)
• halfint operator+ (halfint x)
• halfint operator- (halfint x)
• halfint operator+ (halfint x, int y)
• halfint operator- (halfint x, int y)
• halfint operator * (halfint x, int y)
• float operator * (halfint x, float y)
• double operator * (halfint x, double y)
• long double operator * (halfint x, long double y)
• halfint operator+ (int x, halfint y)
• halfint operator- (int x, halfint y)
• halfint operator * (int x, halfint y)
• float operator * (float x, halfint y)
• double operator * (double x, halfint y)
• long double operator * (long double x, halfint y)
• bool operator== (halfint x, halfint y)
• bool operator!= (halfint x, halfint y)
• bool operator< (halfint x, halfint y)
• bool operator> (halfint x, halfint y)
• bool operator<= (halfint x, halfint y)
• bool operator>= (halfint x, halfint y)
• bool operator== (halfint x, int y)
• bool operator!= (halfint x, int y)
• bool operator< (halfint x, int y)
• bool operator> (halfint x, int y)
• bool operator<= (halfint x, int y)
• bool operator>= (halfint x, int y)
• bool operator== (int x, halfint y)
• bool operator!= (int x, halfint y)
• bool operator< (int x, halfint y)
• bool operator> (int x, halfint y)
• bool operator<= (int x, halfint y)
• bool operator>= (int x, halfint y)
• halfint operator+ (int x, pm_half y)
• halfint operator- (int x, pm_half y)
• halfint operator+ (pm_half x, int y)
• halfint operator- (pm_half x, int y)
• halfint ceil (halfint x)
• halfint floor (halfint x)
• halfint trunc (halfint x)
• int iceil (halfint x)
• int ifloor (halfint x)
• int itrunc (halfint x)
• halfint abs (halfint x)
• halfint min (halfint x, halfint y)
• halfint max (halfint x, halfint y)
• template<typename T> T pow (T x, halfint y)
• template<typename T> T pow (T x, half_tag)
• template<typename T> T pow (T x, minus_half_tag)
• double clebsch (halfint j1, halfint j2, halfint j3, halfint m1, halfint m2, halfint m3)
• double threejm (halfint j1, halfint j2, halfint j3, halfint m1, halfint m2, halfint m3)
• double sixj (halfint j11, halfint j12, halfint j13, halfint j21, halfint j22, halfint j23)
• double ninej (halfint j11, halfint j12, halfint j13, halfint j21, halfint j22, halfint j23, halfint j31, halfint j32, halfint j33)
• bool threej (halfint j1, halfint j2, halfint j3)
• std::ostream & operator<< (std::ostream &out, halfint x)
• std::istream & operator>> (std::istream &in, halfint &x)
• bool operator!= (pm_one x, pm_one y)
• bool operator<= (pm_one x, pm_one y)
• bool operator> (pm_one x, pm_one y)
• bool operator>= (pm_one x, pm_one y)
• bool operator!= (pm_one x, one_tag y)
• bool operator<= (pm_one x, one_tag y)
• bool operator> (pm_one x, one_tag y)
• bool operator>= (pm_one x, one_tag y)
• bool operator!= (pm_one x, minus_one_tag y)
• bool operator<= (pm_one x, minus_one_tag y)
• bool operator> (pm_one x, minus_one_tag y)
• bool operator>= (pm_one x, minus_one_tag y)
• bool operator!= (one_tag x, pm_one y)
• bool operator<= (one_tag x, pm_one y)
• bool operator> (one_tag x, pm_one y)
• bool operator>= (one_tag x, pm_one y)
• bool operator!= (minus_one_tag x, pm_one y)
• bool operator<= (minus_one_tag x, pm_one y)
• bool operator> (minus_one_tag x, pm_one y)
• bool operator>= (minus_one_tag x, pm_one y)
• template<typename T> T operator * (pm_one pi, const T &x)
• template<typename T> T operator * (const T &x, pm_one pi)
• pm_one where (bool c, one_tag x, minus_one_tag y)
• pm_one where (bool c, minus_one_tag x, one_tag y)
• one_tag where (bool, one_tag, one_tag)
• minus_one_tag where (bool, minus_one_tag, minus_one_tag)
• pm_one where (bool c, pm_one x, pm_one y)
• std::istream & operator>> (std::istream &, pm_one &)
• double mathfunc_precision (double *)
• float mathfunc_precision (float *)
• template<typename T> T abs_or_norm (T const &x)
• template<typename T> T abs_or_norm (complex< T > const &x)
• double f1c (int)
• double f2c (int)
• double fhc (int)
• double f1h (int)
• template<typename T, typename U> U nonterminating_hypergeometric (T alpha, T beta, T gamma, U z)
• template<typename T, typename U> U terminating_hypergeometric (int alpha, T beta, T gamma, U z)
• template<typename T, typename U> U hypergeometric (halfint alpha, halfint beta, T gamma, U z)
• template<typename T, typename U> U hypergeometric (int alpha, int beta, T gamma, U z)
• template<typename T1, typename T2, typename U> U hypergeometric (halfint alpha, T1 beta, T2 gamma, U z)
• template<typename T1, typename T2, typename U> U hypergeometric (int alpha, T1 beta, T2 gamma, U z)
• template<typename T1, typename T2, typename U> U hypergeometric (T1 alpha, int beta, T2 gamma, U z)
• template<typename T1, typename T2, typename U> U hypergeometric (T1 alpha, halfint beta, T2 gamma, U z)
• template<typename T1, typename T2, typename T3, typename U> U hypergeometric (T1 alpha, T2 beta, T3 gamma, U z)
• template<typename T> T lgamma (T z)
• template<typename T> T gamma (T z)
• int gamma (int i)
• double lgamma (int i)
• template<typename T1, typename T2, typename U> U legP (T1 nu, T2 mu, U z)
• template<typename T> T legP (int n, int m, T x)
• template<typename T> complex< typename norm_type_<
  T >::eval > sphY (int l, int m, T theta, T phi)
• template<typename T> T herH (int n, T const &x)
• template<typename T, typename U> T lagL (int n, U alpha, T x)
• template<typename T> T besj (int, T)
• template<typename T> spinor< T > operator * (T x, alpha_tag)
• template<typename T> spinor< T > operator * (T x, beta_tag)
• template<typename T> spinopr< T > operator * (T x, sigma_x_tag)
• template<typename T> spinopr< T > operator * (sigma_x_tag, T y)
• template<typename T> spinopr< T > operator * (const spinopr< T > &x, sigma_x_tag)
• template<typename T> spinopr< T > operator * (sigma_x_tag, const spinopr< T > &y)
• template<typename T> spinopr< T > operator+ (const spinopr< T > &x, sigma_x_tag)
• template<typename T> spinopr< T > operator+ (sigma_x_tag, const spinopr< T > &y)
• template<typename T> spinor< T > operator+ (const spinor< T > &x)
• template<typename T> spinor< T > operator- (const spinor< T > &x)
• template<typename T, typename U> spinor< typename plus_type_<
  T, U >::eval > operator+ (const spinor< T > &x, const spinor< U > &y)
• template<typename T, typename U> spinor< typename minus_type_<
  T, U >::eval > operator- (const spinor< T > &x, const spinor< U > &y)
• template<typename T> spinor< T > operator * (const spinor< T > &x, T y)
• template<typename T> spinor< T > operator * (T x, const spinor< T > &y)
• template<typename T> spinor< T > operator/ (const spinor< T > &x, T y)
• template<typename T> spinor< std::complex< T > > operator * (const spinor< std::complex< T > > &x, T y)
• template<typename T> spinor< std::complex< T > > operator * (T x, const spinor< std::complex< T > > &y)
• template<typename T> spinor< std::complex< T > > operator/ (const spinor< std::complex< T > > &x, T y)
• template<typename T> spinor< T > operator * (const spinor< T > &x, const std::complex< T > &y)
• template<typename T> spinor< T > operator * (const std::complex< T > &x, const spinor< T > &y)
• template<typename T> spinor< T > operator/ (const spinor< T > &x, const std::complex< T > &y)
• template<typename T> spinopr< T > operator+ (const spinopr< T > &x)
• template<typename T> spinopr< T > operator- (const spinopr< T > &x)
• template<typename T, typename U> spinopr< typename plus_type_<
  T, U >::eval > operator+ (const spinopr< T > &x, const spinopr< U > &y)
• template<typename T, typename U> spinopr< typename minus_type_<
  T, U >::eval > operator- (const spinopr< T > &x, const spinopr< U > &y)
• template<typename T, typename U> spinopr< typename times_type_<
  T, U >::eval > operator * (const spinopr< T > &x, const spinopr< U > &y)
• template<typename T, typename U> spinopr< typename plus_type_<
  T, U >::eval > operator+ (const spinopr< T > &x, U y)
• template<typename T, typename U> spinopr< typename plus_type_<
  T, U >::eval > operator+ (T x, const spinopr< U > &y)
• template<typename T, typename U> spinopr< typename minus_type_<
  T, U >::eval > operator- (const spinopr< T > &x, U y)
• template<typename T, typename U> spinopr< typename minus_type_<
  T, U >::eval > operator- (T x, const spinopr< U > &y)
• template<typename T, typename U> spinopr< typename times_type_<
  T, U >::eval > operator * (const spinopr< T > &x, U y)
• template<typename T, typename U> spinopr< typename times_type_<
  T, U >::eval > operator * (T x, const spinopr< U > &y)
• template<typename T, typename U> spinopr< typename divides_type_<
  T, U >::eval > operator/ (const spinopr< T > &x, U y)
• template<typename T> spinor< T > operator * (const spinopr< T > &x, const spinor< T > &y)
• template<typename T> std::ostream & operator<< (std::ostream &, const spinor< T > &)
• template<typename T> std::ostream & operator<< (std::ostream &, const spinopr< T > &)
• template<typename T> std::istream & operator>> (std::istream &, spinor< T > &)
• template<typename T> std::istream & operator>> (std::istream &, spinopr< T > &)
• template<typename T> norm_type_< T >::eval norm (const spinor< T > &x)
• template<typename T> norm_type_< T >::eval abs (const spinor< T > &x)
• template<typename T> norm_type_< T >::eval norm (const spinopr< T > &x)
• template<typename T> norm_type_< T >::eval abs (const spinopr< T > &x)
• template<typename T> T dot (const spinor< T > &x, const spinor< T > &y)
• template<typename T> T real_dot (const spinor< std::complex< T > > &x, const spinor< std::complex< T > > &y)
• template<typename T> spinopr< T > outer_prod (const spinor< T > &x, const spinor< T > &y)
• template<typename T> spinopr< T > adj (const spinopr< T > &x)
• template<typename T> T trace (const spinopr< T > &x)
• template<typename T> T det (const spinopr< T > &x)
• template<typename T> T sum (const spinor< T > &x)
• template<typename T> bool finite (const spinor< T > &x)
• template<typename T> bool finite (const spinopr< T > &x)
• template<typename T> spinopr< T > sin (spinopr< T > const &x)
• template<typename T> spinopr< T > cos (spinopr< T > const &x)
• template<typename T> spinopr< T > tan (spinopr< T > const &x)
• template<typename T> spinopr< T > sinh (spinopr< T > const &x)
• template<typename T> spinopr< T > cosh (spinopr< T > const &x)
• template<typename T> spinopr< T > tanh (spinopr< T > const &x)
• template<typename T> spinopr< T > exp (spinopr< T > const &x)
• template<typename T> spinopr< T > log (spinopr< T > const &x)
• template<typename T> spinopr< T > sqrt (spinopr< T > const &x)

Variables

• onei_tag onei
• coalpha_tag coalpha
• cobeta_tag cobeta
• zero_tag zero
• one_tag one
• half_tag half
• alpha_tag alpha
• beta_tag beta
• sigma_x_tag sigma_x
• sigma_y_tag sigma_y
• sigma_z_tag sigma_z

---

Detailed Description

Mathematical types and functions.

Types like half-integers, spinors and spin operators. A supposedly strong hash function (but don't use it for security). Various mathematical functions.

---

Function Documentation

template<typename T> norm_type_<T>::eval abs (  const spinopr< T > &    x )  [inline]

template<typename T> norm_type_<T>::eval abs (  const spinor< T > &    x )  [inline]

halfint abs (  halfint    x )  [inline]

template<typename T> T abs (  T const &    x )  [inline]

template<typename T> norm_type_<T>::eval abs (  const cospinor< T > &    x )  [inline]

template<typename T> T abs_or_norm (  complex< T > const &    x )  [inline]

template<typename T> T abs_or_norm (  T const &    x )  [inline]

template<typename T> spinopr<T> adj (  const spinopr< T > &    x )  [inline]

template<typename T> spinor<T> adj (  const cospinor< T > &    x )  [inline]

template<typename T> cospinor<T> adj (  const spinor< T > &    x )  [inline]

long double adj (  long double    x )  [inline]

double adj (  double    x )  [inline]

float adj (  float    x )  [inline]

template<typename T> complex<T> adj (  complex< T > const &    x )  [inline]

double besir (  int   , double    )

double besIr (  double   , double    )

template<typename T> T more::math::besj (  int    n, T    x )

double besjr (  int   , double    )

int binominal (  int    n, int    i )  [inline]

long double bitpow (  long    double, int    )

double bitpow (  double   , int    )

float bitpow (  float   , int    )

unsigned long more::math::bitpow (  unsigned    long, int    )

halfint ceil (  halfint    x )  [inline]

template<typename T> T center (  interval_base< T > const &    I )  [inline]

double clebsch (  halfint    j1, halfint    j2, halfint    j3, halfint    m1, halfint    m2, halfint    m3 )  [inline]

double clebsch_2j (  int   , int   , int   , int   , int   , int    )

long double conj (  long double    x )  [inline]

double conj (  double    x )  [inline]

float conj (  float    x )  [inline]

template<typename T> spinopr<T> cos (  spinopr< T > const &    x )

template<typename T> spinopr<T> cosh (  spinopr< T > const &    x )

lang::uint_least64_t decode64_alnum (  char const *    s )

Decodes a 64 bits number encoded with encode64_alnum. This function may me moved to another header and namespace.

unsigned char decode_alnum (  char    ch )  [inline]

Decode an integer encoded with encode_alnum.

unsigned char decode_alpha (  char    ch )  [inline]

Decode an integer encoded with encode_alpha.

template<typename T> T det (  const spinopr< T > &    x )  [inline]

template<typename T> T dot (  const spinor< T > &    x, const spinor< T > &    y )  [inline]

long double dot (  long double    x, long double    y )  [inline]

double dot (  double    x, double    y )  [inline]

float dot (  float    x, float    y )  [inline]

complex<long double> dot (  complex< long double > const &    x, complex< long double > const &    y )  [inline]

complex<double> dot (  complex< double > const &    x, complex< double > const &    y )  [inline]

complex<float> dot (  complex< float > const &    x, complex< float > const &    y )  [inline]

int double_factorial (  int    n, int    m = 0 )  [inline]

void encode64_alnum (  lang::uint_least64_t   , char *    s )

Encodes a 64 bits numbers into 1 ASCII alphabetic followed by 10 ASCII alphanumeric characters. This function may me moved to another header and namespace.

char encode_alnum (  unsigned int    k )  [inline]

Encode an integer in the range [0..62) as an alphanumeric ASCII character.

char encode_alpha (  unsigned int    k )  [inline]

Encode an integer in the range [0.. 52) as an alphabetic ASCII character.

int enumerator (  pm_half    x )  [inline]

int enumerator (  minus_half_tag    )  [inline]

int enumerator (  half_tag    )  [inline]

template<typename T> spinopr<T> exp (  spinopr< T > const &    x )

double f1c (  int    n )

double f1h (  int    n )

double f2c (  int    n )

int factorial (  int    n, int    m = 0 )  [inline]

double fhc (  int    n )

template<typename T> bool finite (  const spinopr< T > &    x )  [inline]

template<typename T> bool finite (  const spinor< T > &    x )  [inline]

int finite (  double    x )  [inline]

template<typename T> bool finite (  const cospinor< T > &    x )  [inline]

template<typename T> int finite (  complex< T > const &    x )  [inline]

halfint floor (  halfint    x )  [inline]

int gamma (  int    i )  [inline]

template<typename T> T gamma (  T    z )  [inline]

lang::uint_least32_t hash_id32 (  char    ch0 = 0, char    ch1 = 0, char    ch2 = 0, char    ch3 = 0, char    ch4 = 0, char    ch5 = 0 )  [inline]

Returns a 32 bits encoding of 6 lower case characters. This may be useful for putting tags into hashes. Picking a random number does the same effect, though macro can increases readability, and together with a consistent scheme help avoid collisions without resorting to big random numbers. All sequences of letters of the same case will give differt values. Mixing lower case letters with uppercase or digits may lead to collitions.

template<typename T> T herH (  int    n, T const &    x )  [inline]

template<typename T1, typename T2, typename T3, typename U> U hypergeometric (  T1    alpha, T2    beta, T3    gamma, U    z )  [inline]

template<typename T1, typename T2, typename U> U hypergeometric (  T1    alpha, halfint    beta, T2    gamma, U    z )  [inline]

template<typename T1, typename T2, typename U> U hypergeometric (  T1    alpha, int    beta, T2    gamma, U    z )  [inline]

template<typename T1, typename T2, typename U> U hypergeometric (  int    alpha, T1    beta, T2    gamma, U    z )  [inline]

template<typename T1, typename T2, typename U> U hypergeometric (  halfint    alpha, T1    beta, T2    gamma, U    z )  [inline]

template<typename T, typename U> U hypergeometric (  int    alpha, int    beta, T    gamma, U    z )  [inline]

template<typename T, typename U> U hypergeometric (  halfint    alpha, halfint    beta, T    gamma, U    z )  [inline]

int iceil (  halfint    x )  [inline]

int iceil (  double    x )  [inline]

int ifloor (  halfint    x )  [inline]

int ifloor (  double    x )  [inline]

long double imag (  long double    x )  [inline]

double imag (  double    x )  [inline]

float imag (  float    x )  [inline]

int iround (  double    x )  [inline]

int itrunc (  halfint    x )  [inline]

int itrunc (  double    x )  [inline]

template<typename T, typename U> T lagL (  int    n, U    alpha, T    x )  [inline]

double lagLc (  int   , int    )

long lceil (  double    x )  [inline]

unsigned long ldexp (  unsigned long    x, int    n )  [inline]

unsigned int ldexp (  unsigned int    x, int    n )  [inline]

int ldexp (  long    x, int    n )  [inline]

int ldexp (  int    x, int    n )  [inline]

template<typename T> T legP (  int    n, int    m, T    x )  [inline]

template<typename T1, typename T2, typename U> U legP (  T1    nu, T2    mu, U    z )  [inline]

template<typename T> T length (  interval_base< T > const &    I )  [inline]

long lfloor (  double    x )  [inline]

double lgamma (  int    i )  [inline]

template<typename T> T lgamma (  T    z )  [inline]

template<typename T> spinopr<T> log (  spinopr< T > const &    x )

int lower_bit (  unsigned    int )

long lround (  double    x )  [inline]

long ltrunc (  double    x )  [inline]

template<typename T> interval<T> make_interval (  T const &    x, bool    lt, T const &    y, bool    rt )

template<typename T, typename Less> interval<T, Less> make_interval (  T const &    x, bool    lt, T const &    y, bool    rt, Less    less = std::less<T>() )

float mathfunc_precision (  float *    )

double mathfunc_precision (  double *    )

halfint max (  halfint    x, halfint    y )  [inline]

template<typename T> T max (  T const &    x, T const &    y )  [inline]

halfint min (  halfint    x, halfint    y )  [inline]

template<typename T> T min (  T const &    x, T const &    y )  [inline]

double ninej (  halfint    j11, halfint    j12, halfint    j13, halfint    j21, halfint    j22, halfint    j23, halfint    j31, halfint    j32, halfint    j33 )  [inline]

double ninej_2j (  int   , int   , int   , int   , int   , int   , int   , int   , int    )

template<typename T, typename U> U nonterminating_hypergeometric (  T    alpha, T    beta, T    gamma, U    z )  [inline]

template<typename T> norm_type_<T>::eval norm (  const spinopr< T > &    x )  [inline]

template<typename T> norm_type_<T>::eval norm (  const spinor< T > &    x )  [inline]

long double norm (  long double    x )  [inline]

double norm (  double    x )  [inline]

float norm (  float    x )  [inline]

int norm (  int    x )  [inline]

unsigned int norm (  unsigned int    x )  [inline]

template<typename T> norm_type_<T>::eval norm (  const cospinor< T > &    x )  [inline]

template<typename T> spinor<T> operator * (  const spinopr< T > &    x, const spinor< T > &    y )  [inline]

template<typename T, typename U> spinopr<typename times_type_<T, U>::eval> operator * (  T    x, const spinopr< U > &    y )  [inline]

template<typename T, typename U> spinopr<typename times_type_<T, U>::eval> operator * (  const spinopr< T > &    x, U    y )  [inline]

template<typename T, typename U> spinopr<typename times_type_<T, U>::eval> operator * (  const spinopr< T > &    x, const spinopr< U > &    y )  [inline]

template<typename T> spinor<T> operator * (  const std::complex< T > &    x, const spinor< T > &    y )  [inline]

template<typename T> spinor<T> operator * (  const spinor< T > &    x, const std::complex< T > &    y )  [inline]

template<typename T> spinor< std::complex<T> > operator * (  T    x, const spinor< std::complex< T > > &    y )  [inline]

template<typename T> spinor< std::complex<T> > operator * (  const spinor< std::complex< T > > &    x, T    y )  [inline]

template<typename T> spinor<T> operator * (  T    x, const spinor< T > &    y )  [inline]

template<typename T> spinor<T> operator * (  const spinor< T > &    x, T    y )  [inline]

template<typename T> spinopr< T > more::math::operator * (  sigma_x_tag   , const spinopr< T > &    y )  [inline]

template<typename T> spinopr< T > more::math::operator * (  const spinopr< T > &    x, sigma_x_tag    )  [inline]

template<typename T> spinopr< T > more::math::operator * (  sigma_x_tag   , T    y )  [inline]

template<typename T> spinopr< T > more::math::operator * (  T    x, sigma_x_tag    )  [inline]

template<typename T> spinor<T> operator * (  T    x, beta_tag    )  [inline]

template<typename T> spinor<T> operator * (  T    x, alpha_tag    )  [inline]

template<typename T> T operator * (  const T &    x, pm_one    pi )  [inline]

template<typename T> T operator * (  pm_one    pi, const T &    x )  [inline]

long double operator * (  long double    x, halfint    y )  [inline]

double operator * (  double    x, halfint    y )  [inline]

float operator * (  float    x, halfint    y )  [inline]

halfint operator * (  int    x, halfint    y )  [inline]

long double operator * (  halfint    x, long double    y )  [inline]

double operator * (  halfint    x, double    y )  [inline]

float operator * (  halfint    x, float    y )  [inline]

halfint operator * (  halfint    x, int    y )  [inline]

long double operator * (  half_tag   , long double    y )  [inline]

long double operator * (  long double    x, half_tag    )  [inline]

double operator * (  half_tag   , double    y )  [inline]

double operator * (  double    x, half_tag    )  [inline]

float operator * (  half_tag   , float    y )  [inline]

float operator * (  float    x, half_tag    )  [inline]

halfint operator * (  minus_half_tag   , int    y )  [inline]

halfint operator * (  int    x, minus_half_tag    )  [inline]

halfint operator * (  half_tag   , int    y )  [inline]

halfint operator * (  int    x, half_tag    )  [inline]

long double operator * (  long double    x, pm_half    y )  [inline]

double operator * (  double    x, pm_half    y )  [inline]

float operator * (  float    x, pm_half    y )  [inline]

long double operator * (  pm_half    x, long double    y )  [inline]

double operator * (  pm_half    x, double    y )  [inline]

float operator * (  pm_half    x, float    y )  [inline]

template<typename T> T operator * (  const T &    x, minus_one_tag    )  [inline]

template<typename T> T operator * (  minus_one_tag   , const T &    x )  [inline]

template<typename T> T operator * (  const T &    x, one_tag    )  [inline]

template<typename T> T operator * (  one_tag   , const T &    x )  [inline]

template<typename T> zero_tag operator * (  T   , zero_tag    )  [inline]

template<typename T> zero_tag operator * (  zero_tag   , T    )  [inline]

template<typename T> cospinor<T> operator * (  const cospinor< T > &    x, const spinopr< T > &    y )  [inline]

template<typename T, typename U> spinopr< typename times_type_<T, U>::eval > operator * (  const spinor< T > &    x, const cospinor< U > &    y )  [inline]

template<typename T, typename U> times_type_<T, U>::eval operator * (  const cospinor< T > &    x, const spinor< U > &    y )  [inline]

template<typename T, typename U> cospinor< typename times_type_<T, U>::eval > operator * (  T    x, const cospinor< U > &    y )  [inline]

template<typename T, typename U> cospinor< typename times_type_<T, U>::eval > operator * (  const cospinor< T > &    x, U    y )  [inline]

template<typename T> T operator * (  const cospinor< T > &    x, beta_tag    )  [inline]

template<typename T> T operator * (  const cospinor< T > &    x, alpha_tag    )  [inline]

template<typename T> T more::math::operator * (  coalpha_tag   , const spinor< T > &    x )  [inline]

template<typename T> cospinor< T > more::math::operator * (  T    x, coalpha_tag    )  [inline]

long double more::math::operator * (  minus_onei_tag   , long double    y )  [inline]

double more::math::operator * (  minus_onei_tag   , double    y )  [inline]

float more::math::operator * (  minus_onei_tag   , float    y )  [inline]

complex<long double> operator * (  onei_tag   , long double    x )  [inline]

complex<double> operator * (  onei_tag   , double    x )  [inline]

complex<float> operator * (  onei_tag   , float    x )  [inline]

long double more::math::operator * (  long double    x, minus_onei_tag    )  [inline]

double more::math::operator * (  double    x, minus_onei_tag    )  [inline]

float more::math::operator * (  float    x, minus_onei_tag    )  [inline]

complex<long double> operator * (  long double    x, onei_tag    )  [inline]

complex<double> operator * (  double    x, onei_tag    )  [inline]

complex<float> operator * (  float    x, onei_tag    )  [inline]

template<typename T> complex<T> operator * (  minus_onei_tag   , const complex< T > &    y )  [inline]

template<typename T> complex<T> operator * (  const complex< T > &    x, minus_onei_tag    )  [inline]

template<typename T> complex<T> operator * (  onei_tag   , const complex< T > &    y )  [inline]

template<typename T> complex<T> operator * (  const complex< T > &    x, onei_tag    )  [inline]

bool operator!= (  minus_one_tag    x, pm_one    y )  [inline]

bool operator!= (  one_tag    x, pm_one    y )  [inline]

bool operator!= (  pm_one    x, minus_one_tag    y )  [inline]

bool operator!= (  pm_one    x, one_tag    y )  [inline]

bool operator!= (  pm_one    x, pm_one    y )  [inline]

bool operator!= (  int    x, halfint    y )  [inline]

bool operator!= (  halfint    x, int    y )  [inline]

bool operator!= (  halfint    x, halfint    y )  [inline]

bool operator!= (  minus_half_tag    x, pm_half    y )  [inline]

bool operator!= (  half_tag    x, pm_half    y )  [inline]

bool operator!= (  pm_half    x, minus_half_tag    y )  [inline]

bool operator!= (  pm_half    x, half_tag    y )  [inline]

bool operator!= (  pm_half    x, pm_half    y )  [inline]

template<typename T, typename U> spinopr<typename plus_type_<T, U>::eval> operator+ (  T    x, const spinopr< U > &    y )  [inline]

template<typename T, typename U> spinopr<typename plus_type_<T, U>::eval> operator+ (  const spinopr< T > &    x, U    y )  [inline]

template<typename T, typename U> spinopr<typename plus_type_<T, U>::eval> operator+ (  const spinopr< T > &    x, const spinopr< U > &    y )  [inline]

template<typename T> spinopr<T> operator+ (  const spinopr< T > &    x )  [inline]

template<typename T, typename U> spinor< typename plus_type_<T, U>::eval > operator+ (  const spinor< T > &    x, const spinor< U > &    y )  [inline]

template<typename T> spinor<T> operator+ (  const spinor< T > &    x )  [inline]

template<typename T> spinopr< T > more::math::operator+ (  sigma_x_tag   , const spinopr< T > &    y )  [inline]

template<typename T> spinopr< T > more::math::operator+ (  const spinopr< T > &    x, sigma_x_tag    )  [inline]

halfint operator+ (  pm_half    x, int    y )  [inline]

halfint operator+ (  int    x, pm_half    y )  [inline]

halfint operator+ (  int    x, halfint    y )  [inline]

halfint operator+ (  halfint    x, int    y )  [inline]

halfint operator+ (  halfint    x )  [inline]

halfint operator+ (  halfint    x, halfint    y )  [inline]

halfint operator+ (  minus_half_tag   , int    x )  [inline]

halfint operator+ (  int    x, minus_half_tag    )  [inline]

halfint operator+ (  half_tag   , int    x )  [inline]

halfint operator+ (  int    x, half_tag    )  [inline]

halfint operator+ (  minus_half_tag   , halfint    x )  [inline]

halfint operator+ (  halfint    x, minus_half_tag    )  [inline]

halfint operator+ (  half_tag   , halfint    x )  [inline]

halfint operator+ (  halfint    x, half_tag    )  [inline]

int operator+ (  pm_half    x, pm_half    y )  [inline]

int operator+ (  pm_half    x, minus_half_tag    )  [inline]

int operator+ (  minus_half_tag   , pm_half    x )  [inline]

int operator+ (  pm_half    x, half_tag    )  [inline]

int operator+ (  half_tag   , pm_half    x )  [inline]

half_tag operator+ (  half_tag    )  [inline]

template<typename T> T operator+ (  const T &    x, zero_tag    )  [inline]

template<typename T> T operator+ (  zero_tag   , const T &    x )  [inline]

minus_half_tag more::math::operator+ (  minus_one_tag    )  [inline]

one_tag operator+ (  one_tag    )  [inline]

template<typename T, typename U> cospinor< typename plus_type_<T, U>::eval > operator+ (  const cospinor< T > &    x, const cospinor< U > &    y )  [inline]

template<typename T> cospinor<T> operator+ (  const cospinor< T > &    x )  [inline]

template<typename T, typename U> spinopr<typename minus_type_<T, U>::eval> operator- (  T    x, const spinopr< U > &    y )  [inline]

template<typename T, typename U> spinopr<typename minus_type_<T, U>::eval> operator- (  const spinopr< T > &    x, U    y )  [inline]

template<typename T, typename U> spinopr<typename minus_type_<T, U>::eval> operator- (  const spinopr< T > &    x, const spinopr< U > &    y )  [inline]

template<typename T> spinopr<T> operator- (  const spinopr< T > &    x )  [inline]

template<typename T, typename U> spinor< typename minus_type_<T, U>::eval > operator- (  const spinor< T > &    x, const spinor< U > &    y )  [inline]

template<typename T> spinor<T> operator- (  const spinor< T > &    x )  [inline]

halfint operator- (  pm_half    x, int    y )  [inline]

halfint operator- (  int    x, pm_half    y )  [inline]

halfint operator- (  int    x, halfint    y )  [inline]

halfint operator- (  halfint    x, int    y )  [inline]

halfint operator- (  halfint    x )  [inline]

halfint operator- (  halfint    x, halfint    y )  [inline]

halfint operator- (  minus_half_tag   , int    x )  [inline]

halfint operator- (  int    x, minus_half_tag    )  [inline]

halfint operator- (  half_tag   , int    x )  [inline]

halfint operator- (  int    x, half_tag    )  [inline]

halfint operator- (  minus_half_tag   , halfint    x )  [inline]

halfint operator- (  halfint    x, minus_half_tag    )  [inline]

halfint operator- (  half_tag   , halfint    x )  [inline]

halfint operator- (  halfint    x, half_tag    )  [inline]

int operator- (  pm_half    x, pm_half    y )  [inline]

int operator- (  pm_half    x, minus_half_tag    )  [inline]

int operator- (  minus_half_tag   , pm_half    x )  [inline]

int operator- (  pm_half    x, half_tag    )  [inline]

int operator- (  half_tag   , pm_half    x )  [inline]

minus_half_tag operator- (  half_tag    )  [inline]

template<typename T> T operator- (  const T &    x, zero_tag    )  [inline]

template<typename T> T operator- (  zero_tag   , const T &    x )  [inline]

template<typename T, typename U> cospinor< typename minus_type_<T, U>::eval > operator- (  const cospinor< T > &    x, const cospinor< U > &    y )  [inline]

template<typename T> cospinor<T> operator- (  const cospinor< T > &    x )  [inline]

half_tag more::math::operator- (  minus_onei_tag    )  [inline]

minus_one_tag more::math::operator- (  onei_tag    )  [inline]

template<typename T, typename U> spinopr<typename divides_type_<T, U>::eval> operator/ (  const spinopr< T > &    x, U    y )  [inline]

template<typename T> spinor<T> operator/ (  const spinor< T > &    x, const std::complex< T > &    y )  [inline]

template<typename T> spinor< std::complex<T> > operator/ (  const spinor< std::complex< T > > &    x, T    y )  [inline]

template<typename T> spinor<T> operator/ (  const spinor< T > &    x, T    y )  [inline]

template<typename T> T operator/ (  const T &    x, minus_one_tag    )  [inline]

template<typename T> T operator/ (  const T &    x, one_tag    )  [inline]

template<typename T> zero_tag operator/ (  zero_tag   , T    )  [inline]

template<typename T, typename U> cospinor< typename divides_type_<T, U>::eval > operator/ (  const cospinor< T > &    x, U    y )  [inline]

bool operator< (  int    x, halfint    y )  [inline]

bool operator< (  halfint    x, int    y )  [inline]

bool operator< (  halfint    x, halfint    y )  [inline]

template<typename T> std::ostream& operator<< (  std::ostream &   , const spinopr< T > &    )

template<typename T> std::ostream& operator<< (  std::ostream &   , const spinor< T > &    )

std::ostream& operator<< (  std::ostream &    out, halfint    x )

std::ostream & more::math::operator<< (  std::ostream &   , pm_half    )

template<unsigned int Width> std::ostream& operator<< (  std::ostream &    os, hash< Width > const &    h )  [inline]

template<typename T> std::ostream& operator<< (  std::ostream &   , const cospinor< T > &    )

bool operator<= (  minus_one_tag    x, pm_one    y )  [inline]

bool operator<= (  one_tag    x, pm_one    y )  [inline]

bool operator<= (  pm_one    x, minus_one_tag    y )  [inline]

bool operator<= (  pm_one    x, one_tag    y )  [inline]

bool operator<= (  pm_one    x, pm_one    y )  [inline]

bool operator<= (  int    x, halfint    y )  [inline]

bool operator<= (  halfint    x, int    y )  [inline]

bool operator<= (  halfint    x, halfint    y )  [inline]

bool operator== (  int    x, halfint    y )  [inline]

bool operator== (  halfint    x, int    y )  [inline]

bool operator== (  halfint    x, halfint    y )  [inline]

bool operator== (  minus_half_tag    x, pm_half    y )  [inline]

bool operator== (  half_tag    x, pm_half    y )  [inline]

bool operator> (  minus_one_tag    x, pm_one    y )  [inline]

bool operator> (  one_tag    x, pm_one    y )  [inline]

bool operator> (  pm_one    x, minus_one_tag    y )  [inline]

bool operator> (  pm_one    x, one_tag    y )  [inline]

bool operator> (  pm_one    x, pm_one    y )  [inline]

bool operator> (  int    x, halfint    y )  [inline]

bool operator> (  halfint    x, int    y )  [inline]

bool operator> (  halfint    x, halfint    y )  [inline]

bool operator>= (  minus_one_tag    x, pm_one    y )  [inline]

bool operator>= (  one_tag    x, pm_one    y )  [inline]

bool operator>= (  pm_one    x, minus_one_tag    y )  [inline]

bool operator>= (  pm_one    x, one_tag    y )  [inline]

bool operator>= (  pm_one    x, pm_one    y )  [inline]

bool operator>= (  int    x, halfint    y )  [inline]

bool operator>= (  halfint    x, int    y )  [inline]

bool operator>= (  halfint    x, halfint    y )  [inline]

template<typename T> std::istream& operator>> (  std::istream &   , spinopr< T > &    )

template<typename T> std::istream& operator>> (  std::istream &   , spinor< T > &    )

std::istream& operator>> (  std::istream &   , pm_one &    )

std::istream& operator>> (  std::istream &    in, halfint &    x )

std::istream& operator>> (  std::istream &   , pm_half &    )

template<typename T> std::istream& operator>> (  std::istream &   , cospinor< T > &    )

template<typename T> spinopr<T> outer_prod (  const spinor< T > &    x, const spinor< T > &    y )  [inline]

template<typename T> T pow (  T    x, minus_half_tag    )  [inline]

template<typename T> T pow (  T    x, half_tag    )  [inline]

template<typename T> T pow (  T    x, halfint    y )  [inline]

template<typename T> T pow10 (  const T &    x )  [inline]

template<typename T> T pow2 (  const T &    x )  [inline]

template<typename T> T pow3 (  const T &    x )  [inline]

template<typename T> T pow4 (  const T &    x )  [inline]

template<typename T> T pow5 (  const T &    x )  [inline]

template<typename T> T pow6 (  const T &    x )  [inline]

template<typename T> T pow7 (  const T &    x )  [inline]

template<typename T> T pow8 (  const T &    x )  [inline]

template<typename T> T pow9 (  const T &    x )  [inline]

template<typename T> int rank (  T const &    x )  [inline]

int rank (  long    double )  [inline]

int rank (  double    )  [inline]

int rank (  float    )  [inline]

template<typename T> int rank (  complex< T > const &    )  [inline]

long double real (  long double    x )  [inline]

double real (  double    x )  [inline]

float real (  float    x )  [inline]

template<typename T> T real_dot (  const spinor< std::complex< T > > &    x, const spinor< std::complex< T > > &    y )  [inline]

template<typename T> T real_dot (  const cospinor< std::complex< T > > &    x, const cospinor< std::complex< T > > &    y )  [inline]

template<typename T> spinopr<T> sin (  spinopr< T > const &    x )

template<typename T> spinopr<T> sinh (  spinopr< T > const &    x )

double sixj (  halfint    j11, halfint    j12, halfint    j13, halfint    j21, halfint    j22, halfint    j23 )  [inline]

double sixj_2j (  int   , int   , int   , int   , int   , int    )

template<typename T> int size0 (  T const &    x )  [inline]

int size0 (  long    double )  [inline]

int size0 (  double    )  [inline]

int size0 (  float    )  [inline]

template<typename T> int size0 (  complex< T > const &    )  [inline]

template<typename T> int size1 (  T const &    x )  [inline]

int size1 (  long    double )  [inline]

int size1 (  double    )  [inline]

int size1 (  float    )  [inline]

template<typename T> int size1 (  complex< T > const &    )  [inline]

template<typename T> int size2 (  T const &    x )  [inline]

int size2 (  long    double )  [inline]

int size2 (  double    )  [inline]

int size2 (  float    )  [inline]

template<typename T> int size2 (  complex< T > const &    )  [inline]

template<typename T> complex<typename norm_type_<T>::eval> sphY (  int    l, int    m, T    theta, T    phi )  [inline]

template<typename T> spinopr<T> sqrt (  spinopr< T > const &    x )

template<typename T> T& subscript (  T &    x, int    i, int    j = 0, int    k = 0 )  [inline]

template<typename T> T subscript (  T const &    x, int    i, int    j = 0, int    k = 0 )  [inline]

template<typename T> T sum (  const spinor< T > &    x )  [inline]

template<typename T> T sum (  const cospinor< T > &    x )  [inline]

template<typename T> spinopr<T> tan (  spinopr< T > const &    x )

template<typename T> spinopr<T> tanh (  spinopr< T > const &    x )

template<typename T, typename U> U terminating_hypergeometric (  int    alpha, T    beta, T    gamma, U    z )  [inline]

bool threej (  halfint    j1, halfint    j2, halfint    j3 )  [inline]

double threejm (  halfint    j1, halfint    j2, halfint    j3, halfint    m1, halfint    m2, halfint    m3 )  [inline]

double threejm_2j (  int   , int   , int   , int   , int   , int    )

template<typename T> T trace (  const spinopr< T > &    x )  [inline]

template<typename T> T trace (  T const &    x )  [inline]

template<typename T> complex<T> trace (  complex< T > const &    x )  [inline]

halfint trunc (  halfint    x )  [inline]

int upper_bit (  unsigned    int )

pm_one where (  bool    c, pm_one    x, pm_one    y )  [inline]

minus_one_tag where (  bool   , minus_one_tag   , minus_one_tag    )  [inline]

one_tag where (  bool   , one_tag   , one_tag    )  [inline]

pm_one where (  bool    c, minus_one_tag    x, one_tag    y )  [inline]

pm_one where (  bool    c, one_tag    x, minus_one_tag    y )  [inline]

---

Variable Documentation

alpha_tag more::math::alpha

beta_tag more::math::beta

coalpha_tag more::math::coalpha

cobeta_tag more::math::cobeta

half_tag more::math::half

one_tag more::math::one

onei_tag more::math::onei

sigma_x_tag more::math::sigma_x

sigma_y_tag more::math::sigma_y

sigma_z_tag more::math::sigma_z

zero_tag more::math::zero

---