Unary Plus

template<typename T>
quaternion<T> operator + (quaternion<T> const & q);

Этот унарный оператор просто возвращает q.

Unary Minus

template<typename T>
quaternion<T> operator - (quaternion<T> const & q);

Этот унарный оператор возвращает противоположность q.

Binary Addition Operators

template<typename T> quaternion<T> operator + (T const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, T const & rhs);
template<typename T> quaternion<T> operator + (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> quaternion<T> operator + (quaternion<T> const & lhs, quaternion<T> const & rhs);

Эти операторы возвращаются<quaternion<T>(lhs)+= rhs>.

Binary Subtraction Operators

template<typename T> quaternion<T> operator - (T const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, T const & rhs);
template<typename T> quaternion<T> operator - (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> quaternion<T> operator - (quaternion<T> const & lhs, quaternion<T> const & rhs);

Операторы возвращаются<quaternion<T>(lhs)-= rhs>.

Binary Multiplication Operators

template<typename T> quaternion<T> operator * (T const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, T const & rhs);
template<typename T> quaternion<T> operator * (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> quaternion<T> operator * (quaternion<T> const & lhs, quaternion<T> const & rhs);

Операторы возвращаются<quaternion<T>(lhs)*= rhs>.

Binary Division Operators

template<typename T> quaternion<T> operator / (T const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, T const & rhs);
template<typename T> quaternion<T> operator / (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> quaternion<T> operator / (quaternion<T> const & lhs, quaternion<T> const & rhs);

Операторы возвращаются<quaternion<T>(lhs)/= rhs>. Это, конечно, ошибка, чтобы разделить на ноль.

Equality Operators

template<typename T> bool  operator == (T const & lhs, quaternion<T> const & rhs);
template<typename T> bool  operator == (quaternion<T> const & lhs, T const & rhs);
template<typename T> bool  operator == (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> bool  operator == (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> bool  operator == (quaternion<T> const & lhs, quaternion<T> const & rhs);

Они возвращаются истинными тогда и только тогда, когда четыре компонента<quaternion<T>(lhs)>равны их аналогам в<quaternion<T>(rhs)>. Как и в случае с любым объектом плавающего типа, это по существу бессмысленно.

Inequality Operators

template<typename T> bool  operator != (T const & lhs, quaternion<T> const & rhs);
template<typename T> bool  operator != (quaternion<T> const & lhs, T const & rhs);
template<typename T> bool  operator != (::std::complex<T> const & lhs, quaternion<T> const & rhs);
template<typename T> bool  operator != (quaternion<T> const & lhs, ::std::complex<T> const & rhs);
template<typename T> bool  operator != (quaternion<T> const & lhs, quaternion<T> const & rhs);

Они возвращаются истинными тогда и только тогда, когда они ложны6. Как и в случае с любым объектом плавающего типа, это по существу бессмысленно.

Stream Extractor

template<typename T, typename charT, class traits>
::std::basic_istream<charT,traits>& operator >> (::std::basic_istream<charT,traits> & is, quaternion<T> & q);

Извлекает кватернион q одной из следующих форм (с a, b, c и d типа<T>):

<a (a), (a,b), (a,b,c), (a,b,c,d) (a,(c)), (a,(c,d)), ((a)), ((a),c), ((a),(c)), ((a),(c,d)), ((a,b)), ((a,b),c), ((a,b),(c)), ((a,b),(c,d))>

Входные значения должны быть конвертируемы в<T>. Если вы столкнулись с плохим входом, звоните<is.setstate(ios::failbit)>(что может привести к провалу (27.4.5.3)).

Возвращение:<is>.

Обоснованием для списка принятых форматов является то, что либо у нас есть список до четырех реалов, либо у нас есть пара сложных чисел, и в том случае, если он оформлен как правильное комплексное число, то его следует принять. Таким образом, потенциальные двусмысленности отбрасываются (например, (a,b) есть (a,b,0,0), а не (a,0,b,0), т.е. он разбирается как список двух действительных чисел, а не двух комплексных чисел, которые имеют воображаемые части, равные нулю.

Stream Inserter

template<typename T, typename charT, class traits>
::std::basic_ostream<charT,traits>& operator << (::std::basic_ostream<charT,traits> & os, quaternion<T> const & q);

Вставляет кватернион q в поток<os>, как если бы он был реализован следующим образом:

template<typename T, typename charT, class traits>
::std::basic_ostream<charT,traits>& operator << (
               ::std::basic_ostream<charT,traits> & os,
               quaternion<T> const & q)
{
   ::std::basic_ostringstream<charT,traits>  s;
   s.flags(os.flags());
   s.imbue(os.getloc());
   s.precision(os.precision());
   s << '(' << q.R_component_1() << ','
            << q.R_component_2() << ','
            << q.R_component_3() << ','
            << q.R_component_4() << ')';
   return os << s.str();
}