gps_pvt 0.1.1

data/ext/ninja-scan-light/tool/param/bit_array.h

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2021, M.Naruoka (fenrir)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the naruoka.org nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/** @file
+ * @brief bit array library as an alternation of std::bitset
+ */
+
+
+#ifndef __BIT_ARRAY_H__
+#define __BIT_ARRAY_H__
+
+#include <climits>
+#include <cstring>
+#include <cstdlib>
+
+#include <vector>
+
+template <int denom, int pow2 = 1, int log2 = 0, int rem2 = denom % pow2>
+struct const_div_t : public std::div_t {
+  const_div_t(const int &num) : std::div_t(std::div(num, denom)) {}
+};
+template <int denom, int pow2, int log2>
+struct const_div_t<denom, pow2, log2, 0> : public const_div_t<denom, (pow2 << 1), log2 + 1> {
+  const_div_t(const int &num) : const_div_t<denom, (pow2 << 1), log2 + 1>(num) {}
+};
+template <int denom, int log2>
+struct const_div_t<denom, denom, log2, 0> {
+  int quot, rem;
+  const_div_t(const int &num) : quot(num >> log2), rem(num & (denom - 1)) {}
+};
+
+template <int MAX_SIZE, class ContainerT = unsigned char>
+struct BitArray {
+  static const int bits_per_addr = (int)sizeof(ContainerT) * CHAR_BIT;
+  ContainerT buf[(MAX_SIZE + bits_per_addr - 1) / bits_per_addr];
+  void set(const bool &new_bit = false) {
+    std::memset(buf, (new_bit ? (~0) : 0), sizeof(buf));
+  }
+  void reset() {set(false);}
+  void clear() {reset();}
+
+  bool operator[](const int &idx) const {
+    if((idx < 0) || (idx >= MAX_SIZE)){return false;}
+    const_div_t<bits_per_addr> qr(idx);
+    ContainerT mask((ContainerT)1 << qr.rem);
+    return buf[qr.quot] & mask;
+  }
+  void set(const int &idx, const bool &bit = true) {
+    if((idx < 0) || (idx >= MAX_SIZE)){return;}
+    const_div_t<bits_per_addr> qr(idx);
+    ContainerT mask((ContainerT)1 << qr.rem);
+    bit ? (buf[qr.quot] |= mask) : (buf[qr.quot] &= ~mask);
+  }
+  void reset(const int &idx) {
+    set(idx, false);
+  }
+  /**
+   * Generate bit pattern with arbitrary start and end indices
+   */
+  unsigned int pattern(const int &idx_lsb, int idx_msb) const {
+    if((idx_msb < idx_lsb) || (idx_lsb < 0) || (idx_msb >= MAX_SIZE)){
+      return 0;
+    }
+    static const int res_bits((int)sizeof(unsigned int) * CHAR_BIT);
+    if((idx_msb - idx_lsb) >= res_bits){
+      // check output boundary; if overrun, msb will be truncated.
+      idx_msb = idx_lsb + res_bits - 1;
+    }
+
+    const_div_t<bits_per_addr> qr_lsb(idx_lsb), qr_msb(idx_msb);
+    if(res_bits > bits_per_addr){
+      unsigned int res(buf[qr_msb.quot] & ((qr_msb.rem == bits_per_addr - 1)
+          ? ~((ContainerT)0)
+          : (((ContainerT)1 << (qr_msb.rem + 1)) - 1))); // MSB byte
+      if(qr_msb.quot > qr_lsb.quot){
+        for(int i(qr_msb.quot - 1); i > qr_lsb.quot; --i){ // Fill intermediate
+          res <<= bits_per_addr;
+          res |= buf[i];
+        }
+        res <<= (bits_per_addr - qr_lsb.rem);
+        res |= (buf[qr_lsb.quot] >> qr_lsb.rem); // Last byte
+      }else{
+        res >>= qr_lsb.rem;
+      }
+      return res;
+    }else{
+      ContainerT res(buf[qr_msb.quot] & ((qr_msb.rem == bits_per_addr - 1)
+          ? ~((ContainerT)0)
+          : (((ContainerT)1 << (qr_msb.rem + 1)) - 1))); // MSB byte
+      if(qr_msb.quot > qr_lsb.quot){
+        res <<= (bits_per_addr - qr_lsb.rem);
+        res |= (buf[qr_lsb.quot] >> qr_lsb.rem); // Last byte
+      }else{
+        res >>= qr_lsb.rem;
+      }
+      return (unsigned int)res;
+    }
+  }
+  std::vector<int> indices_one() const {
+    std::vector<int> res;
+    int idx(0);
+    static const const_div_t<bits_per_addr> qr(MAX_SIZE);
+    int rem(qr.rem);
+    for(int i(0); i < qr.quot; ++i, idx += bits_per_addr){
+      int idx2(idx);
+      for(ContainerT temp(buf[i]); temp > 0; temp >>= 1, ++idx2){
+        if(temp & 0x1){res.push_back(idx2);}
+      }
+    }
+    for(ContainerT temp(buf[qr.quot + 1]); (temp > 0) && (rem > 0); --rem, ++idx, temp >>= 1){
+      if(temp & 0x1){res.push_back(idx);}
+    }
+    return res;
+  }
+};
+
+#endif /* __BIT_ARRAY_H__ */

data/ext/ninja-scan-light/tool/param/complex.h

@@ -0,0 +1,558 @@
+/*
+ * Copyright (c) 2015, M.Naruoka (fenrir)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the naruoka.org nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __COMPLEX_H
+#define __COMPLEX_H
+
+#include <exception>
+#include <string>
+
+#include <cmath>
+#include <limits>
+
+#if (__cplusplus < 201103L) && !defined(noexcept)
+#define noexcept throw()
+#endif
+
+/** @file
+ * @brief ���f�����C�u����
+ *
+ * ���f�����`�������C�u�����B
+ * �����N������Ă������悤�Ȋ����ɂȂ�Ǝv����B
+ */
+
+/**
+ * @brief ���f��
+ *
+ * ���f��������킷�N���X�ł��B
+ *
+ * @param FloatT ���Z���x�Adouble�Ȃ�
+ */
+template <class FloatT>
+class Complex{
+  private:
+    FloatT m_Real; ///< ����
+    FloatT m_Imaginary; ///< ����
+  public:
+   /**
+    * �R���X�g���N�^�B
+    *
+    * @param real ������
+    * @param imaginary ������
+    */
+    Complex(const FloatT &real, const FloatT &imaginary) noexcept
+         : m_Real(real), m_Imaginary(imaginary){}
+
+    /**
+     * �R���X�g���N�^�B
+     * ��������0�ŏ���������܂��B
+     *
+     * @param real ������
+     */
+    Complex(const FloatT &real) noexcept : m_Real(real), m_Imaginary(0){}
+
+    /**
+     * �R���X�g���N�^�B
+     * �������A�������Ƃ���0�ɏ���������܂��B
+     *
+     */
+    Complex() noexcept : m_Real(0), m_Imaginary(0){}
+
+    /**
+     * �f�X�g���N�^�B
+     *
+     */
+    ~Complex() noexcept {}
+
+    static Complex<FloatT> polar(const FloatT &r, const FloatT &theta = FloatT(0)){
+      return Complex<FloatT>(r * std::cos(theta), r * std::sin(theta));
+    }
+
+    /**
+     * ��������Ԃ��܂��B
+     *
+     * @return (FloatT) ������
+     */
+    const FloatT &real() const noexcept {return m_Real;}
+    FloatT &real() noexcept {
+      return const_cast<FloatT &>(static_cast<const Complex &>(*this).real());
+    }
+    /**
+     * ��������Ԃ��܂��B
+     *
+     * @return (FloatT) ������
+     */
+    const FloatT &imaginary() const noexcept {return m_Imaginary;}
+    FloatT &imaginary() noexcept {
+      return const_cast<FloatT &>(static_cast<const Complex &>(*this).imaginary());
+    }
+
+    Complex<FloatT> &operator=(const Complex<FloatT> &another) noexcept {
+      m_Real = another.m_Real;
+      m_Imaginary = another.m_Imaginary;
+      return *this;
+    }
+    Complex<FloatT> &operator=(const FloatT &another) noexcept {
+      m_Real = another;
+      m_Imaginary = 0;
+      return *this;
+    }
+
+  protected:
+#if (__cplusplus < 201103L)
+    // @see https://stackoverflow.com/a/411781
+    template <class T = FloatT, bool has_infinity = std::numeric_limits<T>::has_infinity>
+    struct check_infinity_t;
+    template <class T>
+    struct check_infinity_t<T, true> {
+      static bool isinf(const Complex<T> &value) noexcept {
+        return (value.m_Real == std::numeric_limits<T>::infinity())
+            || (value.m_Real == -std::numeric_limits<T>::infinity())
+            || (value.m_Imaginary == std::numeric_limits<T>::infinity())
+            || (value.m_Imaginary == -std::numeric_limits<T>::infinity());
+      }
+    };
+#else
+    template <class T = FloatT>
+    struct check_infinity_t {
+      static bool isinf(const Complex<T> &value) noexcept {
+        return std::isinf(value.m_Real) || std::isinf(value.m_Imaginary);
+      }
+    };
+#endif
+
+  public:
+    bool isinf() const noexcept {
+      return check_infinity_t<>::isinf(*this);
+    }
+    bool isfinite() const noexcept {
+      return !isinf();
+    }
+
+    /**
+     * ��Βl�̓���Ԃ��܂��B
+     * std::pow(real(), 2) + std::pow(imaginary(), 2)�����Ă��܂��B
+     *
+     * @return (FloatT) ��Βl�̓��
+     * @see pow(FloatT, FloatT)
+     */
+    FloatT abs2() const noexcept {return std::pow(m_Real, 2) + std::pow(m_Imaginary, 2);}
+    /**
+     * ��Βl��Ԃ��܂��B
+     * sqrt(abs2())�����Ă��܂��B
+     *
+     * @return (FloatT) ��Βl
+     * @see abs2()
+     * @see sqrt()
+     */
+    FloatT abs() const {return std::sqrt(abs2());}
+    /**
+     * �Ίp��Ԃ��܂��B
+     *
+     * @return (double) �Ίp
+     */
+    double arg() const {
+      if((m_Real == FloatT(0)) && (m_Imaginary == FloatT(0))){
+        return 0;
+      }
+      return std::atan2(m_Imaginary, m_Real);
+    }
+    /**
+     * �w��悵�܂��B
+     * ��������`�Ƃ��āA���f����
+     * @f[
+     *    a + b i = r e^{i \theta}
+     * @f]
+     * �Ƃ���킳���Ƃ��A
+     * @f[
+     *    (a + b i)^{n} = r^{n} e^{i \theta n}
+     * @f]
+     * �Ƃ��܂��B
+     *
+     * @param factor �搔
+     * @return (Complex<FloatT>) ����
+     */
+    Complex<FloatT> power(const FloatT &factor) const {
+      if((m_Imaginary == FloatT(0)) && (m_Real >= FloatT(0))){
+        return Complex(std::pow(m_Real, factor));
+      }else{
+        FloatT _abs(std::pow(abs(), factor));
+        double _arg(arg() * factor);
+        return Complex(_abs * std::cos(_arg), _abs * std::sin(_arg));
+      }
+    }
+
+    /**
+     * �����������߂܂��B��`��power�ɏ]���܂��B
+     *
+     * @return (Complex<FloatT>) ����
+     * @see power
+     */
+    Complex<FloatT> sqrt() const {
+      return power(FloatT(0.5));
+    }
+
+    /**
+     * ���𕡑f����Ԃ��܂��B
+     *
+     * @return (Complex<FloatT>) ���𕡑f��
+     */
+    Complex<FloatT> conjugate() const noexcept {
+      Complex<FloatT> result = *this;
+      result.imaginary() *= -1;
+      return result;
+    }
+
+    /**
+     * ���������ǂ������ׂ܂��B
+     *
+     * @return (bool) �������ꍇtrue
+     */
+    bool operator==(const Complex<FloatT> &complex) const noexcept {
+      return m_Real == complex.real()
+          ? m_Imaginary == complex.imaginary()
+          : false;
+    }
+    /**
+     * �������Ȃ������ׂ܂��B
+     *
+     * @return (bool) �������Ȃ��ꍇtrue
+     */
+    bool operator!=(const Complex<FloatT> &complex) const noexcept {
+      return !(*this == complex);
+    }
+
+    /**
+     * ���Z���s���܂��B�j��I�ł��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> &operator+=(const FloatT &scalar) noexcept {
+      m_Real += scalar;
+      return *this;
+    }
+    /**
+     * ���Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> operator+(const FloatT &scalar) const noexcept {
+      Complex<FloatT> result = *this;
+      return (result += scalar);
+    }
+    /**
+     * ���Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    friend Complex<FloatT> operator+(const FloatT &scalar, const Complex<FloatT> complex) noexcept {return (complex + scalar);}
+
+    /**
+     * ���Z���s���܂��B�j��I�ł��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> &operator-=(const FloatT &scalar) noexcept {return (*this) += (-scalar);}
+    /**
+     * ���Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> operator-(const FloatT &scalar) const noexcept {return (*this) + (-scalar);}
+    /**
+     * ���Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    friend Complex<FloatT> operator-(const FloatT &scalar, const Complex<FloatT> complex) noexcept {return (complex - scalar);}
+
+    /**
+     * ��Z���s���܂��B�j��I�ł��B
+     *
+     * @return (Complex<FloatT>) ��Z����
+     */
+    Complex<FloatT> &operator *=(const FloatT &scalar) noexcept {
+      m_Real *= scalar;
+      m_Imaginary *= scalar;
+      return *this;
+    }
+    /**
+     * ��Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ��Z����
+     */
+    Complex<FloatT> operator*(const FloatT &scalar) const noexcept {
+      Complex<FloatT> result(*this);
+      return (result *= scalar);
+    }
+    /**
+     * ��Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ��Z����
+     */
+    friend Complex<FloatT> operator*(const FloatT &scalar, const Complex<FloatT> complex) noexcept {return (complex * scalar);}
+
+    /**
+     * ���Z���s���܂��B�j��I�ł��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> &operator/=(const FloatT &scalar){return (*this) *= (1/scalar);}
+    /**
+     * ���Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> operator/(const FloatT &scalar) const{return (*this) * (1/scalar);}
+
+    /**
+     * �P���}�C�i�X�I�y���[�^�B
+     *
+     * @return (Complex<FloatT>) ����
+     */
+    Complex<FloatT> operator -() const noexcept {return ((*this) * -1);}
+
+    /**
+     * ���Z���s���܂��B�j��I�ł��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> &operator+=(const Complex<FloatT> &complex) noexcept {
+      m_Real += complex.real();
+      m_Imaginary += complex.imaginary();
+      return *this;
+    }
+    /**
+     * ���Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> operator+(const Complex<FloatT> &complex) const noexcept {
+      Complex<FloatT> result = *this;
+      return (result += complex);
+    }
+
+    /**
+     * ���Z���s���܂��B�j��I�ł��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> &operator-=(const Complex<FloatT> &complex) noexcept {
+      return ((*this) += (-complex));
+    }
+    /**
+     * ���Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> operator-(const Complex<FloatT> &complex) const noexcept {
+      return ((-complex) += (*this));
+    }
+
+    /**
+     * ��Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ��Z����
+     */
+    Complex<FloatT> operator*(const Complex<FloatT> &complex) const noexcept {
+      return Complex<FloatT>(
+          m_Real * complex.real()      - m_Imaginary * complex.imaginary(),
+          m_Real * complex.imaginary() + m_Imaginary * complex.real());
+    }
+    /**
+     * ��Z���s���܂��B�j��I�ł��B
+     *
+     * @return (Complex<FloatT>) ��Z����
+     */
+    Complex<FloatT> &operator*=(const Complex<FloatT> &complex) noexcept {
+      Complex<FloatT> copy = *this;
+      m_Real =
+        copy.real() * complex.real()
+        - copy.imaginary() * complex.imaginary();
+      m_Imaginary =
+        copy.real() * complex.imaginary()
+        + copy.imaginary() * complex.real();
+      return *this;
+    }
+
+    /**
+     * ���Z���s���܂��B�j��I�ł��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> &operator/=(const Complex<FloatT> &complex){
+      return (*this) *= (complex.conjugate() / complex.abs2());
+    }
+    /**
+     * ���Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    Complex<FloatT> operator/(const Complex<FloatT> &complex) const{
+      Complex<FloatT> copy = (*this);
+      return (copy /= complex);
+    }
+
+    /**
+     * ���Z���s���܂��B
+     *
+     * @return (Complex<FloatT>) ���Z����
+     */
+    friend Complex<FloatT> operator/(const FloatT &scalar, const Complex<FloatT> complex){
+      return Complex<FloatT>(scalar) / complex;
+    }
+
+    /**
+     * �݂₷���`�ŕ��f�����o�͂��܂��B
+     *
+     * @param out �o�̓X�g���[��
+     * @param complex �o�͂��镡�f��
+     */
+    friend std::ostream &operator<<(std::ostream &out, const Complex<FloatT> &complex){
+      out << complex.real() << " + "
+          << complex.imaginary() << "i";
+      return out;
+    }
+
+    /**
+     * e�̎w��������߂܂��B
+     *
+     * @param imaginary ����
+     * @return (Complex<FloatT>) ����
+     */
+    static Complex<FloatT> exp(const FloatT &imaginary) noexcept {
+      return Complex<FloatT>(std::cos(imaginary), std::sin(imaginary));
+    }
+
+    /**
+     * e�̎w��������߂܂��B
+     *
+     * @param real ����
+     * @param imaginary ����
+     * @return (Complex<FloatT>) ����
+     */
+    static Complex<FloatT> exp(const FloatT &real, const FloatT &imaginary) noexcept {
+      return Complex<FloatT>::exp(imaginary) *= std::exp(real);
+    }
+
+    /**
+     * e�̎w��������߂܂��B
+     *
+     * @param complex ���f��
+     * @return (Complex<FloatT>) ����
+     */
+    static Complex<FloatT> exp(const Complex<FloatT> &complex) noexcept {
+      return Complex<FloatT>::exp(
+          complex.real(), complex.imaginary());
+    }
+};
+
+/**
+ * exp�̕��f���g��
+ *
+ * @param real ����
+ * @param imaginary ����
+ * @param FloatT ���Z���x
+ * @return (Complex<FloatT>) ����
+ */
+template <class FloatT>
+inline Complex<FloatT> iexp(const FloatT &real, const FloatT &imaginary) noexcept {
+  return Complex<FloatT>::exp(real, imaginary);
+}
+
+/**
+ * exp�̕��f���g��
+ * @param imaginary ����
+ * @param FloatT ���Z���x
+ * @return (Complex<FloatT>) ����
+ */
+template <class FloatT>
+inline Complex<FloatT> iexp(const FloatT &imaginary) noexcept {
+  return Complex<FloatT>::exp(imaginary);
+}
+
+namespace std {
+
+/**
+ * exp�̕��f���g��
+ *
+ * @param complex ���f��
+ * @param FloatT ���Z���x
+ * @return (Complex<FloatT>) ����
+ */
+template <class FloatT>
+inline Complex<FloatT> exp(const Complex<FloatT> &complex) noexcept {
+  return Complex<FloatT>::exp(complex);
+}
+
+/**
+ * pow�̕��f���g��
+ *
+ * @param complex ���f��
+ * @param FloatT ���Z���x
+ * @return (Complex<FloatT>) ����
+ */
+template <class FloatT>
+inline Complex<FloatT> pow(const Complex<FloatT> &complex, const FloatT &factor) noexcept {
+  return complex.power(factor);
+}
+
+/**
+ * sqrt�̕��f���g��
+ *
+ * @param complex ���f��
+ * @param FloatT ���Z���x
+ * @return (Complex<FloatT>) ����
+ */
+template <class FloatT>
+inline Complex<FloatT> sqrt(const Complex<FloatT> &complex){
+  return complex.sqrt();
+}
+
+/**
+ * Calculate absolute value of a complex value
+ *
+ * @param complex target
+ * @param FloatT precision
+ * @return (Complex<FloatT>) result
+ */
+template <class FloatT>
+inline FloatT abs(const Complex<FloatT> &complex) noexcept {
+  return complex.abs();
+}
+
+} // namespace
+
+#if (__cplusplus < 201103L) && defined(noexcept)
+#undef noexcept
+#endif
+
+#endif /* __COMPLEX_H */