Шаблонная версия:
explicit octonion(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T(), T const & requested_e = T(), T const & requested_f = T(), T const & requested_g = T(), T const & requested_h = T());
explicit octonion(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>(), ::std::complex<T> const & z2 = ::std::complex<T>(), ::std::complex<T> const & z3 = ::std::complex<T>());
explicit octonion(::boost::math::quaternion<T> const & q0, ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>());
template<typename X>
explicit octonion(octonion<X> const & a_recopier);
Версия специализации Float:
explicit octonion(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f, float const & requested_e = 0.0f, float const & requested_f = 0.0f, float const & requested_g = 0.0f, float const & requested_h = 0.0f);
explicit octonion(::std::complex<float> const & z0, ::std::complex<float> const & z1 = ::std::complex<float>(), ::std::complex<float> const & z2 = ::std::complex<float>(), ::std::complex<float> const & z3 = ::std::complex<float>());
explicit octonion(::boost::math::quaternion<float> const & q0, ::boost::math::quaternion<float> const & q1 = ::boost::math::quaternion<float>());
explicit octonion(octonion<double> const & a_recopier);
explicit octonion(octonion<long double> const & a_recopier);
Двойная версия специализации:
explicit octonion(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0, double const & requested_e = 0.0, double const & requested_f = 0.0, double const & requested_g = 0.0, double const & requested_h = 0.0);
explicit octonion(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>(), ::std::complex<double> const & z2 = ::std::complex<double>(), ::std::complex<double> const & z3 = ::std::complex<double>());
explicit octonion(::boost::math::quaternion<double> const & q0, ::boost::math::quaternion<double> const & q1 = ::boost::math::quaternion<double>());
explicit octonion(octonion<float> const & a_recopier);
explicit octonion(octonion<long double> const & a_recopier);
Длинная двойная специализация:
explicit octonion(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L, long double const & requested_e = 0.0L, long double const & requested_f = 0.0L, long double const & requested_g = 0.0L, long double const & requested_h = 0.0L);
explicit octonion( ::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>(), ::std::complex<long double> const & z2 = ::std::complex<long double>(), ::std::complex<long double> const & z3 = ::std::complex<long double>());
explicit octonion(::boost::math::quaternion<long double> const & q0, ::boost::math::quaternion<long double> const & q1 = ::boost::math::quaternion<long double>());
explicit octonion(octonion<float> const & a_recopier);
explicit octonion(octonion<double> const & a_recopier);
Для каждой формы предусмотрен конструктор по умолчанию, который инициализирует каждый компонент к значениям по умолчанию для их типа (то есть нулю для плавающих чисел). Этот конструктор также может принять от одного до восьми аргументов базового типа. Конструктор также предназначен для построения октононов от одного до четырех комплексных чисел, разделяющих один и тот же базовый тип, а другой принимает один или два кватерниона, разделяющих один и тот же базовый тип. Неспециализированный шаблон также включает в себя шаблонный конструктор копий, в то время как специализированные формы имеют конструкторы копий из двух других специализаций, которые являются явными, когда существует риск потери точности. Для неспециализированной формы конструкторы базового типа не должны бросать.
Деструкторы и конструкторы копий (от одного типа) предоставляются компилятором. Конвертирующие конструкторы копий используют шаблонную функцию помощника в «детальном» подименном пространстве.
T real() const;
octonion<T> unreal() const;
Как и комплексное число, октонионы имеют осмысленное понятие «реальной части», но в отличие от них нет осмысленного понятия «воображаемой части». Вместо этого существует «нереальная часть», которая сама по себе является октонионом, и обычно нет ничего проще (в отличие от случая со сложным числом). Их возвращают первые две функции.
T R_component_1() const;
T R_component_2() const;
T R_component_3() const;
T R_component_4() const;
T R_component_5() const;
T R_component_6() const;
T R_component_7() const;
T R_component_8() const;
Октонион, имеющий восемь реальных компонентов, возвращается этими восемью функциями. Следовательно, реальный и R_компонент_1 возвращают одно и то же значение.
::std::complex<T> C_component_1() const;
::std::complex<T> C_component_2() const;
::std::complex<T> C_component_3() const;
::std::complex<T> C_component_4() const;
Октонион также имеет четыре сложных компонента. На самом деле, октононы действительно являются (левым) векторным полем над комплексами, но будьте осторожны, поскольку для любого октониона<o = α + βi + γj + δk + εe' + ζi' + ηj' + θk'>у нас также есть<o
= (α + βi) + (γ + δi)j + (ε + ζi)e' + (η - θi)j'>(обратите внимание на знакминусв последнем факторе). Однако функции C_component_n возвращают комплексы, которые могут быть использованы для построения октониона с помощью конструктора, ине.компоненты октониона на основе<(1, j, e', j')>.
::boost::math::quaternion<T> H_component_1() const;
::boost::math::quaternion<T> H_component_2() const;
Аналогично, для любого октониона<o = α + βi + γj + δk + εe' + ζi' + ηj' + θk'>у нас также есть<o = (α + βi + γj + δk) + (ε + ζi + ηj - θj)e'>, хотя нет значимой векторно-пространственной структуры, основанной на кватернионах. Функции H_component_n возвращают кватернионы, которые могут быть использованы для построения октониона с помощью конструктора.
octonion<T> & operator = (octonion<T> const & a_affecter);
template<typename X>
octonion<T> & operator = (octonion<X> const & a_affecter);
octonion<T> & operator = (T const & a_affecter);
octonion<T> & operator = (::std::complex<T> const & a_affecter);
octonion<T> & operator = (::boost::math::quaternion<T> const & a_affecter);
Они выполняют ожидаемое назначение с модификацией типа, если это необходимо (например, назначение от базового типа установит реальную часть к этому значению, а все другие компоненты к нулю). Для неспециализированной формы операторы назначения базового типа не должны бросать.
octonion<T> & operator += (T const & rhs)
octonion<T> & operator += (::std::complex<T> const & rhs);
octonion<T> & operator += (::boost::math::quaternion<T> const & rhs);
template<typename X>
octonion<T> & operator += (octonion<X> const & rhs);
Они выполняют математическую операцию<(*this)+rhs>и хранят результат в<*this>. Неспециализированная форма имеет защитные ограждения, которых нет в специализированных формах, чтобы обеспечить безопасность исключения. Для неспециализированной формы операторы назначения базового типа не должны бросать.
octonion<T> & operator -= (T const & rhs)
octonion<T> & operator -= (::std::complex<T> const & rhs);
octonion<T> & operator -= (::boost::math::quaternion<T> const & rhs);
template<typename X>
octonion<T> & operator -= (octonion<X> const & rhs);
Они выполняют математическую операцию<(*this)-rhs>и хранят результат в<*this>. Неспециализированная форма имеет защитные ограждения, которых нет в специализированных формах, чтобы обеспечить безопасность исключения. Для неспециализированной формы операторы назначения базового типа не должны бросать.
octonion<T> & operator *= (T const & rhs)
octonion<T> & operator *= (::std::complex<T> const & rhs);
octonion<T> & operator *= (::boost::math::quaternion<T> const & rhs);
template<typename X>
octonion<T> & operator *= (octonion<X> const & rhs);
Они выполняют математическую операцию<(*this)*rhs>в этом порядке (порядок важен, поскольку умножение не является коммутативным для октононов) и сохраняют результат в<*this>. Неспециализированная форма имеет защитные ограждения, которых нет в специализированных формах, чтобы обеспечить безопасность исключения. Для неспециализированной формы операторы назначения базового типа не должны бросать. Кроме того, для ясности, вы всегда должны группировать факторы в умножении по группам из двух, так как умножение даже не ассоциативно на октонионах (хотя есть, конечно, случаи, когда это не имеет значения, это обычно делает).
octonion<T> & operator /= (T const & rhs)
octonion<T> & operator /= (::std::complex<T> const & rhs);
octonion<T> & operator /= (::boost::math::quaternion<T> const & rhs);
template<typename X>
octonion<T> & operator /= (octonion<X> const & rhs);
Они выполняют математическую операцию<(*this)*inverse_of(rhs)>в этом порядке (порядок важен, поскольку умножение не является коммутативным для октононов) и сохраняют результат в<*this>. Неспециализированная форма имеет защитные ограждения, которых нет в специализированных формах, чтобы обеспечить безопасность исключения. Для неспециализированной формы операторы назначения базового типа не должны бросать. Что касается умножения, не забудьте сгруппировать любые два фактора с помощью скобки.
