+#pragma once++#include <ATen/cpu/vec256/intrinsics.h>+#include <ATen/cpu/vec256/vec256_base.h>+#include <ATen/cpu/vec256/vsx/vsx_helpers.h>+#include <ATen/cpu/vec256/vsx/vec256_double_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_float_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_int16_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_int32_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_int64_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_qint32_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_qint8_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_quint8_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_complex_float_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_complex_double_vsx.h>+namespace at {+namespace vec256 {++namespace {++DEFINE_CLAMP_FUNCS(c10::quint8)+DEFINE_CLAMP_FUNCS(c10::qint8)+DEFINE_CLAMP_FUNCS(c10::qint32)+DEFINE_CLAMP_FUNCS(int16_t)+DEFINE_CLAMP_FUNCS(int32_t)+DEFINE_CLAMP_FUNCS(int64_t)+DEFINE_CLAMP_FUNCS(float)+DEFINE_CLAMP_FUNCS(double)++template <>+Vec256<double> inline __inline_attrs fmadd(+    const Vec256<double>& a,+    const Vec256<double>& b,+    const Vec256<double>& c) {+  return Vec256<double>{+      vec_madd(a.vec0(), b.vec0(), c.vec0()),+      vec_madd(a.vec1(), b.vec1(), c.vec1())};+}++template <>+Vec256<int64_t> inline __inline_attrs fmadd(+    const Vec256<int64_t>& a,+    const Vec256<int64_t>& b,+    const Vec256<int64_t>& c) {+  return Vec256<int64_t>{+      a.vec0() * b.vec0() + c.vec0(), a.vec1() * b.vec1() + c.vec1()};+}+template <>+Vec256<int32_t> inline __inline_attrs fmadd(+    const Vec256<int32_t>& a,+    const Vec256<int32_t>& b,+    const Vec256<int32_t>& c) {+  return Vec256<int32_t>{+      a.vec0() * b.vec0() + c.vec0(), a.vec1() * b.vec1() + c.vec1()};+}+template <>+Vec256<int16_t> inline __inline_attrs fmadd(+    const Vec256<int16_t>& a,+    const Vec256<int16_t>& b,+    const Vec256<int16_t>& c) {+  return Vec256<int16_t>{+      a.vec0() * b.vec0() + c.vec0(), a.vec1() * b.vec1() + c.vec1()};+}++DEFINE_REINTERPRET_CAST_TO_ALL_FUNCS(float)+DEFINE_REINTERPRET_CAST_TO_ALL_FUNCS(double)+DEFINE_REINTERPRET_CAST_TO_ALL_FUNCS(int64_t)+DEFINE_REINTERPRET_CAST_TO_ALL_FUNCS(int32_t)+DEFINE_REINTERPRET_CAST_TO_ALL_FUNCS(int16_t)++template <>+Vec256<int64_t> inline __inline_attrs convert_to_int_of_same_size<double>(+    const Vec256<double>& src) {+  return Vec256<int64_t>{vec_signed(src.vec0()), vec_signed(src.vec1())};+}++template <>+Vec256<int32_t> inline __inline_attrs convert_to_int_of_same_size<float>(+    const Vec256<float>& src) {+  return Vec256<int32_t>{vec_signed(src.vec0()), vec_signed(src.vec1())};+}++template <>+inline void convert(const int32_t* src, float* dst, int64_t n) {+  // int32_t and float have same size+  size_t N = n;+  size_t NE = N & (~(Vec256<int32_t>::size() - 1));+  for (size_t i = 0; i < NE; i += Vec256<int32_t>::size()) {+    const int32_t* src_a = src + i;+    float* dst_a = dst + i;+    __vi input_vec0 = vec_vsx_ld(offset0, reinterpret_cast<const __vi*>(src_a));+    __vi input_vec1 =+        vec_vsx_ld(offset16, reinterpret_cast<const __vi*>(src_a));+    vec_vsx_st(vec_float(input_vec0), offset0, dst_a);

+

++#pragma once+#include <ATen/cpu/vec256/intrinsics.h>+#include <ATen/cpu/vec256/vec256_base.h>+#include <ATen/cpu/vec256/vsx/vsx_helpers.h>+#include <c10/util/complex.h>++namespace at {+namespace vec256 {+// See Note [Acceptable use of anonymous namespace in header]+namespace {+using ComplexFlt = c10::complex<float>;++template <>+class Vec256<ComplexFlt> {+ private:+  union {+    struct {+      __vf _vec0;+      __vf _vec1;+    };+    struct {+      __vib _vecb0;+      __vib _vecb1;+    };++  } __attribute__((__may_alias__));++ public:+  using value_type = ComplexFlt;+  using vec_internal_type = __vf;+  using vec_internal_mask_type = __vib;++  static constexpr int size() {+    return 4;+  }+  Vec256() {}++  __inline_attrs Vec256(__vf v) : _vec0{v}, _vec1{v} {}+  __inline_attrs Vec256(__vib vmask) : _vecb0{vmask}, _vecb1{vmask} {}+  __inline_attrs Vec256(__vf v1, __vf v2) : _vec0{v1}, _vec1{v2} {}+  __inline_attrs Vec256(__vib v1, __vib v2) : _vecb0{v1}, _vecb1{v2} {}++  Vec256(ComplexFlt val) {+    float real_value = val.real();+    float imag_value = val.imag();+    _vec0 = __vf{real_value, imag_value, real_value, imag_value};+    _vec1 = __vf{real_value, imag_value, real_value, imag_value};+  }++  Vec256(ComplexFlt val1, ComplexFlt val2, ComplexFlt val3, ComplexFlt val4) {+    _vec0 = __vf{val1.real(), val1.imag(), val2.real(), val2.imag()};+    _vec1 = __vf{val3.real(), val3.imag(), val4.real(), val4.imag()};+  }++  template <uint64_t mask>+  static std::enable_if_t<blendChoiceComplex(mask) == 0, Vec256<ComplexFlt>>+      __inline_attrs+      blend(const Vec256<ComplexFlt>& a, const Vec256<ComplexFlt>& b) {+    return a;+  }++  template <uint64_t mask>+  static std::enable_if_t<blendChoiceComplex(mask) == 1, Vec256<ComplexFlt>>+      __inline_attrs+      blend(const Vec256<ComplexFlt>& a, const Vec256<ComplexFlt>& b) {+    return b;+  }++  template <uint64_t mask>+  static std::enable_if_t<blendChoiceComplex(mask) == 2, Vec256<ComplexFlt>>+      __inline_attrs+      blend(const Vec256<ComplexFlt>& a, const Vec256<ComplexFlt>& b) {+    return {b._vec0, a._vec1};+  }++  template <uint64_t mask>+  static std::enable_if_t<blendChoiceComplex(mask) == 3, Vec256<ComplexFlt>>+      __inline_attrs+      blend(const Vec256<ComplexFlt>& a, const Vec256<ComplexFlt>& b) {+    return {a._vec0, b._vec1};+  }++  template <uint64_t mask>+  static std::enable_if_t<blendChoiceComplex(mask) == 4, Vec256<ComplexFlt>>+      __inline_attrs+      blend(const Vec256<ComplexFlt>& a, const Vec256<ComplexFlt>& b) {+    const __vib mask_1st = VsxComplexMask1(mask);+    return {(__vf)vec_sel(a._vec0, b._vec0, mask_1st), a._vec1};+  }++  template <uint64_t mask>+  static std::enable_if_t<blendChoiceComplex(mask) == 5, Vec256<ComplexFlt>>+      __inline_attrs+      blend(const Vec256<ComplexFlt>& a, const Vec256<ComplexFlt>& b) {+    const __vib mask_1st = VsxComplexMask1(mask);+    return {(__vf)vec_sel(a._vec0, b._vec0, mask_1st), b._vec1};+  }++  template <uint64_t mask>+  static std::enable_if_t<blendChoiceComplex(mask) == 6, Vec256<ComplexFlt>>+      __inline_attrs+      blend(const Vec256<ComplexFlt>& a, const Vec256<ComplexFlt>& b) {+    const __vib mask_2nd = VsxComplexMask2(mask);+    // generated masks+    return {a._vec0, (__vf)vec_sel(a._vec1, b._vec1, mask_2nd)};+  }++  template <uint64_t mask>+  static std::enable_if_t<blendChoiceComplex(mask) == 7, Vec256<ComplexFlt>>+      __inline_attrs+      blend(const Vec256<ComplexFlt>& a, const Vec256<ComplexFlt>& b) {+    const __vib mask_2nd = VsxComplexMask2(mask);+    // generated masks+    return {b._vec0, (__vf)vec_sel(a._vec1, b._vec1, mask_2nd)};+  }++  template <uint64_t mask>+  static std::enable_if_t<blendChoiceComplex(mask) == 8, Vec256<ComplexFlt>>+      __inline_attrs+      blend(const Vec256<ComplexFlt>& a, const Vec256<ComplexFlt>& b) {+    const __vib mask_1st = VsxComplexMask1(mask);+    const __vib mask_2nd = VsxComplexMask2(mask);+    return {+        (__vf)vec_sel(a._vec0, b._vec0, mask_1st),+        (__vf)vec_sel(a._vec1, b._vec1, mask_2nd)};+  }++  template <int64_t mask>+  static Vec256<ComplexFlt> __inline_attrs+  el_blend(const Vec256<ComplexFlt>& a, const Vec256<ComplexFlt>& b) {+    const __vib mask_1st = VsxMask1(mask);+    const __vib mask_2nd = VsxMask2(mask);+    return {+        (__vf)vec_sel(a._vec0, b._vec0, mask_1st),+        (__vf)vec_sel(a._vec1, b._vec1, mask_2nd)};+  }++  static Vec256<ComplexFlt> blendv(+      const Vec256<ComplexFlt>& a,+      const Vec256<ComplexFlt>& b,+      const Vec256<ComplexFlt>& mask) {+    // convert std::complex<V> index mask to V index mask: xy -> xxyy+    auto mask_complex = Vec256<ComplexFlt>(+        vec_mergeh(mask._vec0, mask._vec0), vec_mergeh(mask._vec1, mask._vec1));+    // mask_complex.dump();+    return {+        vec_sel(a._vec0, b._vec0, mask_complex._vec0),+        vec_sel(a._vec1, b._vec1, mask_complex._vec1),+    };+  }++  static Vec256<ComplexFlt> elwise_blendv(+      const Vec256<ComplexFlt>& a,+      const Vec256<ComplexFlt>& b,+      const Vec256<ComplexFlt>& mask) {+    return {+        vec_sel(a._vec0, b._vec0, mask._vec0),+        vec_sel(a._vec1, b._vec1, mask._vec1),+    };+  }++  template <typename step_t>+  static Vec256<ComplexFlt> arange(+      ComplexFlt base = 0.,+      step_t step = static_cast<step_t>(1)) {+    return Vec256<ComplexFlt>(+        base,+        base + step,+        base + ComplexFlt(2) * step,+        base + ComplexFlt(3) * step);+  }+  static Vec256<ComplexFlt> set(+      const Vec256<ComplexFlt>& a,+      const Vec256<ComplexFlt>& b,+      int64_t count = size()) {+    switch (count) {+      case 0:+        return a;+      case 1:+        return blend<1>(a, b);+      case 2:+        return blend<3>(a, b);+      case 3:+        return blend<7>(a, b);+    }+    return b;+  }++  static Vec256<value_type> __inline_attrs+  loadu(const void* ptr, int count = size()) {+    if (count == size()) {+      return {+          vec_vsx_ld(offset0, reinterpret_cast<const float*>(ptr)),+          vec_vsx_ld(offset16, reinterpret_cast<const float*>(ptr))};+    }++    __at_align32__ value_type tmp_values[size()];+    std::memcpy(tmp_values, ptr, std::min(count, size()) * sizeof(value_type));++    return {+        vec_vsx_ld(offset0, reinterpret_cast<const float*>(tmp_values)),+        vec_vsx_ld(offset16, reinterpret_cast<const float*>(tmp_values))};+  }++  void __inline_attrs store(void* ptr, int count = size()) const {+    if (count == size()) {+      vec_vsx_st(_vec0, offset0, reinterpret_cast<float*>(ptr));+      vec_vsx_st(_vec1, offset16, reinterpret_cast<float*>(ptr));+    } else if (count > 0) {+      __at_align32__ value_type tmp_values[size()];+      vec_vsx_st(_vec0, offset0, reinterpret_cast<float*>(tmp_values));+      vec_vsx_st(_vec1, offset16, reinterpret_cast<float*>(tmp_values));+      std::memcpy(+          ptr, tmp_values, std::min(count, size()) * sizeof(value_type));+    }+  }++  const ComplexFlt& operator[](int idx) const = delete;+  ComplexFlt& operator[](int idx) = delete;++  Vec256<ComplexFlt> map(ComplexFlt (*f)(const ComplexFlt&)) const {+    __at_align32__ ComplexFlt tmp[size()];+    store(tmp);+    for (int i = 0; i < size(); i++) {+      tmp[i] = f(tmp[i]);+    }+    return loadu(tmp);+  }++  static Vec256<ComplexFlt> horizontal_add_permD8(+      Vec256<ComplexFlt>& first,+      Vec256<ComplexFlt>& second) {+    // we will simulate it differently with 6 instructions total+    // lets permute second so that we can add it getting horizontall sums

+#pragma once+#include <ATen/cpu/vec256/intrinsics.h>+#include <ATen/cpu/vec256/vec256_base.h>+#include <ATen/cpu/vec256/vsx/vsx_helpers.h>+#include <c10/util/complex.h>++namespace at {+namespace vec256 {+// See Note [Acceptable use of anonymous namespace in header]+namespace {+using ComplexDbl = c10::complex<double>;++template <>+class Vec256<ComplexDbl> {+  union {+    struct {+      __vd _vec0;+      __vd _vec1;+    };+    struct {+      __vllb _vecb0;+      __vllb _vecb1;+    };++  } __attribute__((__may_alias__));++ public:+  using value_type = ComplexDbl;+  using vec_internal_type = __vd;+  using vec_internal_mask_type = __vllb;+  static constexpr int size() {+    return 2;+  }+  Vec256() {}+  __inline_attrs Vec256(__vd v) : _vec0{v}, _vec1{v} {}+  __inline_attrs Vec256(__vllb vmask) : _vecb0{vmask}, _vecb1{vmask} {}+  __inline_attrs Vec256(__vd v1, __vd v2) : _vec0{v1}, _vec1{v2} {}+  __inline_attrs Vec256(__vllb v1, __vllb v2) : _vecb0{v1}, _vecb1{v2} {}++  Vec256(ComplexDbl val) {+    double real_value = val.real();+    double imag_value = val.imag();+    _vec0 = __vd{real_value, imag_value};+    _vec1 = __vd{real_value, imag_value};+  }+  Vec256(ComplexDbl val1, ComplexDbl val2) {+    _vec0 = __vd{val1.real(), val1.imag()};+    _vec1 = __vd{val2.real(), val2.imag()};+  }++  inline __inline_attrs const vec_internal_type& vec0() const {+    return _vec0;+  }+  inline __inline_attrs const vec_internal_type& vec1() const {+    return _vec1;+  }++  template <int64_t mask>+  static std::enable_if_t<blendChoiceComplexDbl(mask) == 0, Vec256<ComplexDbl>>+      __inline_attrs+      blend(const Vec256<ComplexDbl>& a, const Vec256<ComplexDbl>& b) {+    return a;+  }++  template <int64_t mask>+  static std::enable_if_t<blendChoiceComplexDbl(mask) == 1, Vec256<ComplexDbl>>+      __inline_attrs+      blend(const Vec256<ComplexDbl>& a, const Vec256<ComplexDbl>& b) {+    return b;+  }++  template <int64_t mask>+  static std::enable_if_t<blendChoiceComplexDbl(mask) == 2, Vec256<ComplexDbl>>+      __inline_attrs+      blend(const Vec256<ComplexDbl>& a, const Vec256<ComplexDbl>& b) {+    return {b._vec0, a._vec1};+  }++  template <int64_t mask>+  static std::enable_if_t<blendChoiceComplexDbl(mask) == 3, Vec256<ComplexDbl>>+      __inline_attrs+      blend(const Vec256<ComplexDbl>& a, const Vec256<ComplexDbl>& b) {+    return {a._vec0, b._vec1};+  }++  template <int64_t mask>+  static Vec256<ComplexDbl> __inline_attrs+  el_blend(const Vec256<ComplexDbl>& a, const Vec256<ComplexDbl>& b) {+    const __vllb mask_1st = VsxDblMask1(mask);+    const __vllb mask_2nd = VsxDblMask2(mask);+    return {+        (__vd)vec_sel(a._vec0, b._vec0, mask_1st),+        (__vd)vec_sel(a._vec1, b._vec1, mask_2nd)};+  }++  static Vec256<ComplexDbl> blendv(+      const Vec256<ComplexDbl>& a,+      const Vec256<ComplexDbl>& b,+      const Vec256<ComplexDbl>& mask) {+    // convert std::complex<V> index mask to V index mask: xy -> xxyy+    auto mask_complex =+        Vec256<ComplexDbl>(vec_splat(mask._vec0, 0), vec_splat(mask._vec1, 0));+    return {+        vec_sel(a._vec0, b._vec0, mask_complex._vecb0),+        vec_sel(a._vec1, b._vec1, mask_complex._vecb1)};+  }++  static Vec256<ComplexDbl> __inline_attrs elwise_blendv(+      const Vec256<ComplexDbl>& a,+      const Vec256<ComplexDbl>& b,+      const Vec256<ComplexDbl>& mask) {+    return {+        vec_sel(a._vec0, b._vec0, mask._vecb0),+        vec_sel(a._vec1, b._vec1, mask._vecb1)};+  }+  template <typename step_t>+  static Vec256<ComplexDbl> arange(+      ComplexDbl base = 0.,+      step_t step = static_cast<step_t>(1)) {+    return Vec256<ComplexDbl>(base, base + step);+  }+  static Vec256<ComplexDbl> set(+      const Vec256<ComplexDbl>& a,+      const Vec256<ComplexDbl>& b,+      int64_t count = size()) {+    switch (count) {+      case 0:+        return a;+      case 1:+        return blend<1>(a, b);+    }+    return b;+  }++  static Vec256<value_type> __inline_attrs+  loadu(const void* ptr, int count = size()) {+    if (count == size()) {+      return {+          vec_vsx_ld(offset0, reinterpret_cast<const double*>(ptr)),+          vec_vsx_ld(offset16, reinterpret_cast<const double*>(ptr))};+    }++    __at_align32__ value_type tmp_values[size()];+    std::memcpy(tmp_values, ptr, std::min(count, size()) * sizeof(value_type));++    return {+        vec_vsx_ld(offset0, reinterpret_cast<const double*>(tmp_values)),+        vec_vsx_ld(offset16, reinterpret_cast<const double*>(tmp_values))};+  }+  void __inline_attrs store(void* ptr, int count = size()) const {+    if (count == size()) {+      vec_vsx_st(_vec0, offset0, reinterpret_cast<double*>(ptr));+      vec_vsx_st(_vec1, offset16, reinterpret_cast<double*>(ptr));+    } else if (count > 0) {+      __at_align32__ value_type tmp_values[size()];+      vec_vsx_st(_vec0, offset0, reinterpret_cast<double*>(tmp_values));+      vec_vsx_st(_vec1, offset16, reinterpret_cast<double*>(tmp_values));+      std::memcpy(+          ptr, tmp_values, std::min(count, size()) * sizeof(value_type));+    }+  }++  const ComplexDbl& operator[](int idx) const = delete;+  ComplexDbl& operator[](int idx) = delete;+  Vec256<ComplexDbl> map(ComplexDbl (*f)(const ComplexDbl&)) const {+    __at_align32__ ComplexDbl tmp[size()];+    store(tmp);+    for (int i = 0; i < size(); i++) {+      tmp[i] = f(tmp[i]);+    }+    return loadu(tmp);+  }++  Vec256<ComplexDbl> el_swapped() const {+    __vd v0 = vec_xxpermdi(_vec0, _vec0, 2);+    __vd v1 = vec_xxpermdi(_vec1, _vec1, 2);+    return {v0, v1};+  }++  Vec256<ComplexDbl> el_madd(+      const Vec256<ComplexDbl>& multiplier,+      const Vec256<ComplexDbl>& val) const {+    return {+        vec_madd(_vec0, multiplier._vec0, val._vec0),+        vec_madd(_vec1, multiplier._vec1, val._vec1)};+  }++  Vec256<ComplexDbl> el_mergeo() const {+    __vd v0 = vec_splat(_vec0, 1);+    __vd v1 = vec_splat(_vec1, 1);+    return {v0, v1};+  }++  Vec256<ComplexDbl> el_mergee() const {+    __vd v0 = vec_splat(_vec0, 0);+    __vd v1 = vec_splat(_vec1, 0);+    return {v0, v1};+  }++  static Vec256<ComplexDbl> el_mergee(+      Vec256<ComplexDbl>& first,+      Vec256<ComplexDbl>& second) {+    // as mergee phased in , we can use vec_perm with mask+    return {+        vec_mergeh(first._vec0, second._vec0),+        vec_mergeh(first._vec1, second._vec1)};+  }++  Vec256<ComplexDbl> abs_2_() const {+    auto a = (*this).elwise_mult(*this);+    auto permuted = a.el_swapped();+    a = a + permuted;+    return a;+  }++  Vec256<ComplexDbl> abs_() const {+    auto ret = abs_2_();+    return ret.elwise_sqrt();+  }++  Vec256<ComplexDbl> abs() const {+    return abs_() & vd_real_mask;+  }++  Vec256<ComplexDbl> angle_() const {+    // angle = atan2(b/a)+    // auto b_a = _mm256_permute_pd(values, 0x05);     // b        a+    // return Sleef_atan2d4_u10(values, b_a);          // 90-angle angle+    auto ret = el_swapped();+    for (int i = 0; i < 2; i++) {+      ret._vec0[i] = std::atan2(_vec0[i], ret._vec0[i]);+      ret._vec1[i] = std::atan2(_vec1[i], ret._vec0[i]);+    }+    return ret;+  }++  Vec256<ComplexDbl> angle() const {+    auto a = angle_().el_swapped();+    return a & vd_real_mask;+  }++  Vec256<ComplexDbl> real_() const {+    return *this & vd_real_mask;+  }+  Vec256<ComplexDbl> real() const {+    return *this & vd_real_mask;+  }+  Vec256<ComplexDbl> imag_() const {+    return *this & vd_imag_mask;+  }+  Vec256<ComplexDbl> imag() const {+    return imag_().el_swapped();+  }++  Vec256<ComplexDbl> conj_() const {+    return *this ^ vd_isign_mask;+  }+  Vec256<ComplexDbl> conj() const {+    return *this ^ vd_isign_mask;+  }++  Vec256<ComplexDbl> log() const {+    // Most trigonomic ops use the log() op to improve complex number+    // performance.+    return map(std::log);+  }++  Vec256<ComplexDbl> log2() const {+    // log2eB_inv+    auto ret = log();+    return ret.elwise_mult(vd_log2e_inv);+  }+  Vec256<ComplexDbl> log10() const {+    auto ret = log();+    return ret.elwise_mult(vd_log10e_inv);+  }++  Vec256<ComplexDbl> asin() const {+    // asin(x)+    // = -i*ln(iz + sqrt(1 -z^2))+    // = -i*ln((ai - b) + sqrt(1 - (a + bi)*(a + bi)))+    // = -i*ln((-b + ai) + sqrt(1 - (a**2 - b**2) - 2*abi))+    auto conj = conj_();+    auto b_a = conj.el_swapped();+    auto ab = conj.elwise_mult(b_a);+    auto im = ab + ab;+    auto val_2 = (*this).elwise_mult(*this);+    auto val_2_swapped = val_2.el_swapped();+    auto re = horizontal_sub(val_2, val_2_swapped);+    re = Vec256<ComplexDbl>(vd_one) - re;+    auto root = el_blend<0x0A>(re, im).sqrt();+    auto ln = (b_a + root).log();+    return ln.el_swapped().conj();+  }++  Vec256<ComplexDbl> acos() const {+    // acos(x) = pi/2 - asin(x)+    return Vec256(vd_pi_2) - asin();+  }++  Vec256<ComplexDbl> atan() const {+    // atan(x) = i/2 * ln((i + z)/(i - z))+    auto ione = Vec256(vd_imag_one);+    auto sum = ione + *this;+    auto sub = ione - *this;+    auto ln = (sum / sub).log(); // ln((i + z)/(i - z))+    return ln * vd_imag_half; // i/2*ln()+  }++  Vec256<ComplexDbl> sin() const {+    return map(std::sin);+  }+  Vec256<ComplexDbl> sinh() const {+    return map(std::sinh);+  }+  Vec256<ComplexDbl> cos() const {+    return map(std::cos);+  }+  Vec256<ComplexDbl> cosh() const {+    return map(std::cosh);+  }++  Vec256<ComplexDbl> tan() const {+    return map(std::tan);+  }+  Vec256<ComplexDbl> tanh() const {+    return map(std::tanh);+  }+  Vec256<ComplexDbl> ceil() const {+    return {vec_ceil(_vec0), vec_ceil(_vec1)};+  }+  Vec256<ComplexDbl> floor() const {+    return {vec_floor(_vec0), vec_floor(_vec1)};+  }+  Vec256<ComplexDbl> neg() const {+    auto z = Vec256<ComplexDbl>(vd_zero);+    return z - *this;+  }+  Vec256<ComplexDbl> round() const {+    return {vec_rint(_vec0), vec_rint(_vec1)};+  }++  Vec256<ComplexDbl> trunc() const {+    return {vec_trunc(_vec0), vec_trunc(_vec1)};+  }++  Vec256<ComplexDbl> elwise_sqrt() const {+    return {vec_sqrt(_vec0), vec_sqrt(_vec1)};+  }++  void dump() const {+    std::cout << _vec0[0] << "," << _vec0[1] << ",";+    std::cout << _vec1[0] << "," << _vec1[1] << std::endl;+  }++  Vec256<ComplexDbl> sqrt() const {+    //   sqrt(a + bi)+    // = sqrt(2)/2 * [sqrt(sqrt(a**2 + b**2) + a) + sgn(b)*sqrt(sqrt(a**2 ++    // b**2) - a)i] = sqrt(2)/2 * [sqrt(abs() + a) + sgn(b)*sqrt(abs() - a)i]++    auto sign = *this & vd_isign_mask;+    auto factor = sign | vd_sqrt2_2;+    auto a_a = el_mergee();+    // a_a.dump();+    a_a = a_a ^ vd_isign_mask; // a -a+    auto res_re_im = (abs_() + a_a).elwise_sqrt(); // sqrt(abs + a) sqrt(abs - a)+    return factor.elwise_mult(res_re_im);+  }++  Vec256<ComplexDbl> reciprocal() const {+    // re + im*i = (a + bi)  / (c + di)+    // re = (ac + bd)/abs_2() = c/abs_2()+    // im = (bc - ad)/abs_2() = d/abs_2()+    auto c_d = *this ^ vd_isign_mask; // c       -d+    auto abs = abs_2_();+    return c_d.elwise_div(abs);+  }++  Vec256<ComplexDbl> rsqrt() const {+    return sqrt().reciprocal();+  }++  static Vec256<ComplexDbl> horizontal_add(+      Vec256<ComplexDbl>& first,+      Vec256<ComplexDbl>& second) {+    auto first_perm = first.el_swapped(); // 2perm+    auto second_perm = second.el_swapped(); // 2perm+    // summ+    auto first_ret = first + first_perm; // 2add+    auto second_ret = second + second_perm; // 2 add+    // now lets choose evens+    return el_mergee(first_ret, second_ret); // 2 mergee's+  }++  static Vec256<ComplexDbl> horizontal_sub(+      Vec256<ComplexDbl>& first,+      Vec256<ComplexDbl>& second) {+    // we will simulate it differently with 6 instructions total+    // lets permute second so that we can add it getting horizontall sums

++IF(CMAKE_SYSTEM_NAME MATCHES "Linux")+   message("<FindVSX>")++   EXEC_PROGRAM(LD_SHOW_AUXV=1 ARGS "/bin/true" OUTPUT_VARIABLE bintrue) +   if(bintrue MATCHES "AT_PLATFORM:[ \\t\\n\\r]*([a-zA-Z0-9_]+)[ \\t\\n\\r]*")+    if(CMAKE_MATCH_COUNT GREATER 0)+     string(TOLOWER ${CMAKE_MATCH_1} platform)+     if(${platform} MATCHES "^power")+     message("POWER Platform: ${platform}")+         SET(POWER_COMP TRUE CACHE BOOL "power ")+         SET(CXX_VSX_FLAGS  "${CXX_VSX_FLAGS} -mcpu=${platform} -mtune=${platform}" )+     endif()+   endif()+   endif()+   if(POWER_COMP AND bintrue MATCHES "AT_HWCAP:.*(vsx).*")

+#pragma once+#include <ATen/cpu/vec256/intrinsics.h>+#include <ATen/cpu/vec256/vec256_base.h>+#include <ATen/cpu/vec256/vsx/vsx_helpers.h>+#include <c10/util/complex.h>++namespace at {+namespace vec256 {+// See Note [Acceptable use of anonymous namespace in header]+namespace {+using ComplexDbl = c10::complex<double>;++template <>+class Vec256<ComplexDbl> {+  union {+    struct {+      __vd _vec0;+      __vd _vec1;+    };+    struct {+      __vllb _vecb0;+      __vllb _vecb1;+    };++  } __attribute__((__may_alias__));++ public:+  using value_type = ComplexDbl;+  using vec_internal_type = __vd;+  using vec_internal_mask_type = __vllb;+  static constexpr int size() {+    return 2;+  }+  Vec256() {}+  __inline_attrs Vec256(__vd v) : _vec0{v}, _vec1{v} {}+  __inline_attrs Vec256(__vllb vmask) : _vecb0{vmask}, _vecb1{vmask} {}+  __inline_attrs Vec256(__vd v1, __vd v2) : _vec0{v1}, _vec1{v2} {}+  __inline_attrs Vec256(__vllb v1, __vllb v2) : _vecb0{v1}, _vecb1{v2} {}++  Vec256(ComplexDbl val) {+    double real_value = val.real();+    double imag_value = val.imag();+    _vec0 = __vd{real_value, imag_value};+    _vec1 = __vd{real_value, imag_value};+  }+  Vec256(ComplexDbl val1, ComplexDbl val2) {+    _vec0 = __vd{val1.real(), val1.imag()};+    _vec1 = __vd{val2.real(), val2.imag()};+  }++  inline __inline_attrs const vec_internal_type& vec0() const {+    return _vec0;+  }+  inline __inline_attrs const vec_internal_type& vec1() const {+    return _vec1;+  }++  template <int64_t mask>+  static std::enable_if_t<blendChoiceComplexDbl(mask) == 0, Vec256<ComplexDbl>>+      __inline_attrs+      blend(const Vec256<ComplexDbl>& a, const Vec256<ComplexDbl>& b) {+    return a;+  }++  template <int64_t mask>+  static std::enable_if_t<blendChoiceComplexDbl(mask) == 1, Vec256<ComplexDbl>>+      __inline_attrs+      blend(const Vec256<ComplexDbl>& a, const Vec256<ComplexDbl>& b) {+    return b;+  }++  template <int64_t mask>+  static std::enable_if_t<blendChoiceComplexDbl(mask) == 2, Vec256<ComplexDbl>>+      __inline_attrs+      blend(const Vec256<ComplexDbl>& a, const Vec256<ComplexDbl>& b) {+    return {b._vec0, a._vec1};+  }++  template <int64_t mask>+  static std::enable_if_t<blendChoiceComplexDbl(mask) == 3, Vec256<ComplexDbl>>+      __inline_attrs+      blend(const Vec256<ComplexDbl>& a, const Vec256<ComplexDbl>& b) {+    return {a._vec0, b._vec1};+  }++  template <int64_t mask>+  static Vec256<ComplexDbl> __inline_attrs+  el_blend(const Vec256<ComplexDbl>& a, const Vec256<ComplexDbl>& b) {+    const __vllb mask_1st = VsxDblMask1(mask);+    const __vllb mask_2nd = VsxDblMask2(mask);+    return {+        (__vd)vec_sel(a._vec0, b._vec0, mask_1st),+        (__vd)vec_sel(a._vec1, b._vec1, mask_2nd)};+  }++  static Vec256<ComplexDbl> blendv(+      const Vec256<ComplexDbl>& a,+      const Vec256<ComplexDbl>& b,+      const Vec256<ComplexDbl>& mask) {+    // convert std::complex<V> index mask to V index mask: xy -> xxyy+    auto mask_complex =+        Vec256<ComplexDbl>(vec_splat(mask._vec0, 0), vec_splat(mask._vec1, 0));+    return {+        vec_sel(a._vec0, b._vec0, mask_complex._vecb0),+        vec_sel(a._vec1, b._vec1, mask_complex._vecb1)};+  }++  static Vec256<ComplexDbl> __inline_attrs elwise_blendv(+      const Vec256<ComplexDbl>& a,+      const Vec256<ComplexDbl>& b,+      const Vec256<ComplexDbl>& mask) {+    return {+        vec_sel(a._vec0, b._vec0, mask._vecb0),+        vec_sel(a._vec1, b._vec1, mask._vecb1)};+  }+  template <typename step_t>+  static Vec256<ComplexDbl> arange(+      ComplexDbl base = 0.,+      step_t step = static_cast<step_t>(1)) {+    return Vec256<ComplexDbl>(base, base + step);+  }+  static Vec256<ComplexDbl> set(+      const Vec256<ComplexDbl>& a,+      const Vec256<ComplexDbl>& b,+      int64_t count = size()) {+    switch (count) {+      case 0:+        return a;+      case 1:+        return blend<1>(a, b);+    }+    return b;+  }++  static Vec256<value_type> __inline_attrs+  loadu(const void* ptr, int count = size()) {+    if (count == size()) {+      return {+          vec_vsx_ld(offset0, reinterpret_cast<const double*>(ptr)),+          vec_vsx_ld(offset16, reinterpret_cast<const double*>(ptr))};+    }++    __at_align32__ value_type tmp_values[size()];+    std::memcpy(tmp_values, ptr, std::min(count, size()) * sizeof(value_type));++    return {+        vec_vsx_ld(offset0, reinterpret_cast<const double*>(tmp_values)),+        vec_vsx_ld(offset16, reinterpret_cast<const double*>(tmp_values))};+  }+  void __inline_attrs store(void* ptr, int count = size()) const {+    if (count == size()) {+      vec_vsx_st(_vec0, offset0, reinterpret_cast<double*>(ptr));+      vec_vsx_st(_vec1, offset16, reinterpret_cast<double*>(ptr));+    } else if (count > 0) {+      __at_align32__ value_type tmp_values[size()];+      vec_vsx_st(_vec0, offset0, reinterpret_cast<double*>(tmp_values));+      vec_vsx_st(_vec1, offset16, reinterpret_cast<double*>(tmp_values));+      std::memcpy(+          ptr, tmp_values, std::min(count, size()) * sizeof(value_type));+    }+  }++  const ComplexDbl& operator[](int idx) const = delete;+  ComplexDbl& operator[](int idx) = delete;+  Vec256<ComplexDbl> map(ComplexDbl (*f)(const ComplexDbl&)) const {+    __at_align32__ ComplexDbl tmp[size()];+    store(tmp);+    for (int i = 0; i < size(); i++) {+      tmp[i] = f(tmp[i]);+    }+    return loadu(tmp);+  }++  Vec256<ComplexDbl> el_swapped() const {+    __vd v0 = vec_xxpermdi(_vec0, _vec0, 2);+    __vd v1 = vec_xxpermdi(_vec1, _vec1, 2);+    return {v0, v1};+  }++  Vec256<ComplexDbl> el_madd(+      const Vec256<ComplexDbl>& multiplier,+      const Vec256<ComplexDbl>& val) const {+    return {+        vec_madd(_vec0, multiplier._vec0, val._vec0),+        vec_madd(_vec1, multiplier._vec1, val._vec1)};+  }++  Vec256<ComplexDbl> el_mergeo() const {+    __vd v0 = vec_splat(_vec0, 1);+    __vd v1 = vec_splat(_vec1, 1);+    return {v0, v1};+  }++  Vec256<ComplexDbl> el_mergee() const {+    __vd v0 = vec_splat(_vec0, 0);+    __vd v1 = vec_splat(_vec1, 0);+    return {v0, v1};+  }++  static Vec256<ComplexDbl> el_mergee(+      Vec256<ComplexDbl>& first,+      Vec256<ComplexDbl>& second) {+    // as mergee phased in , we can use vec_perm with mask+    return {+        vec_mergeh(first._vec0, second._vec0),+        vec_mergeh(first._vec1, second._vec1)};+  }++  Vec256<ComplexDbl> abs_2_() const {+    auto a = (*this).elwise_mult(*this);+    auto permuted = a.el_swapped();+    a = a + permuted;+    return a;+  }++  Vec256<ComplexDbl> abs_() const {+    auto ret = abs_2_();+    return ret.elwise_sqrt();+  }++  Vec256<ComplexDbl> abs() const {+    return abs_() & vd_real_mask;+  }++  Vec256<ComplexDbl> angle_() const {+    // angle = atan2(b/a)+    // auto b_a = _mm256_permute_pd(values, 0x05);     // b        a+    // return Sleef_atan2d4_u10(values, b_a);          // 90-angle angle+    auto ret = el_swapped();+    for (int i = 0; i < 2; i++) {+      ret._vec0[i] = std::atan2(_vec0[i], ret._vec0[i]);+      ret._vec1[i] = std::atan2(_vec1[i], ret._vec0[i]);+    }+    return ret;+  }++  Vec256<ComplexDbl> angle() const {+    auto a = angle_().el_swapped();+    return a & vd_real_mask;+  }++  Vec256<ComplexDbl> real_() const {+    return *this & vd_real_mask;+  }+  Vec256<ComplexDbl> real() const {+    return *this & vd_real_mask;+  }+  Vec256<ComplexDbl> imag_() const {+    return *this & vd_imag_mask;+  }+  Vec256<ComplexDbl> imag() const {+    return imag_().el_swapped();+  }++  Vec256<ComplexDbl> conj_() const {+    return *this ^ vd_isign_mask;+  }+  Vec256<ComplexDbl> conj() const {+    return *this ^ vd_isign_mask;+  }++  Vec256<ComplexDbl> log() const {+    // Most trigonomic ops use the log() op to improve complex number+    // performance.+    return map(std::log);+  }++  Vec256<ComplexDbl> log2() const {+    // log2eB_inv+    auto ret = log();+    return ret.elwise_mult(vd_log2e_inv);+  }+  Vec256<ComplexDbl> log10() const {+    auto ret = log();+    return ret.elwise_mult(vd_log10e_inv);+  }++  Vec256<ComplexDbl> asin() const {+    // asin(x)+    // = -i*ln(iz + sqrt(1 -z^2))+    // = -i*ln((ai - b) + sqrt(1 - (a + bi)*(a + bi)))+    // = -i*ln((-b + ai) + sqrt(1 - (a**2 - b**2) - 2*abi))+    auto conj = conj_();+    auto b_a = conj.el_swapped();+    auto ab = conj.elwise_mult(b_a);+    auto im = ab + ab;+    auto val_2 = (*this).elwise_mult(*this);+    auto val_2_swapped = val_2.el_swapped();+    auto re = horizontal_sub(val_2, val_2_swapped);+    re = Vec256<ComplexDbl>(vd_one) - re;+    auto root = el_blend<0x0A>(re, im).sqrt();+    auto ln = (b_a + root).log();+    return ln.el_swapped().conj();+  }++  Vec256<ComplexDbl> acos() const {+    // acos(x) = pi/2 - asin(x)+    return Vec256(vd_pi_2) - asin();+  }++  Vec256<ComplexDbl> atan() const {+    // atan(x) = i/2 * ln((i + z)/(i - z))+    auto ione = Vec256(vd_imag_one);+    auto sum = ione + *this;+    auto sub = ione - *this;+    auto ln = (sum / sub).log(); // ln((i + z)/(i - z))+    return ln * vd_imag_half; // i/2*ln()+  }++  Vec256<ComplexDbl> sin() const {+    return map(std::sin);+  }+  Vec256<ComplexDbl> sinh() const {+    return map(std::sinh);+  }+  Vec256<ComplexDbl> cos() const {+    return map(std::cos);+  }+  Vec256<ComplexDbl> cosh() const {+    return map(std::cosh);+  }++  Vec256<ComplexDbl> tan() const {+    return map(std::tan);+  }+  Vec256<ComplexDbl> tanh() const {+    return map(std::tanh);+  }+  Vec256<ComplexDbl> ceil() const {+    return {vec_ceil(_vec0), vec_ceil(_vec1)};+  }+  Vec256<ComplexDbl> floor() const {+    return {vec_floor(_vec0), vec_floor(_vec1)};+  }+  Vec256<ComplexDbl> neg() const {+    auto z = Vec256<ComplexDbl>(vd_zero);+    return z - *this;+  }+  Vec256<ComplexDbl> round() const {+    return {vec_rint(_vec0), vec_rint(_vec1)};+  }++  Vec256<ComplexDbl> trunc() const {+    return {vec_trunc(_vec0), vec_trunc(_vec1)};+  }++  Vec256<ComplexDbl> elwise_sqrt() const {+    return {vec_sqrt(_vec0), vec_sqrt(_vec1)};+  }++  void dump() const {+    std::cout << _vec0[0] << "," << _vec0[1] << ",";+    std::cout << _vec1[0] << "," << _vec1[1] << std::endl;+  }++  Vec256<ComplexDbl> sqrt() const {+    //   sqrt(a + bi)+    // = sqrt(2)/2 * [sqrt(sqrt(a**2 + b**2) + a) + sgn(b)*sqrt(sqrt(a**2 ++    // b**2) - a)i] = sqrt(2)/2 * [sqrt(abs() + a) + sgn(b)*sqrt(abs() - a)i]++    auto sign = *this & vd_isign_mask;+    auto factor = sign | vd_sqrt2_2;+    auto a_a = el_mergee();+    // a_a.dump();+    a_a = a_a ^ vd_isign_mask; // a -a+    auto res_re_im = (abs_() + a_a).elwise_sqrt(); // sqrt(abs + a) sqrt(abs - a)+    return factor.elwise_mult(res_re_im);+  }++  Vec256<ComplexDbl> reciprocal() const {+    // re + im*i = (a + bi)  / (c + di)+    // re = (ac + bd)/abs_2() = c/abs_2()+    // im = (bc - ad)/abs_2() = d/abs_2()+    auto c_d = *this ^ vd_isign_mask; // c       -d+    auto abs = abs_2_();+    return c_d.elwise_div(abs);+  }++  Vec256<ComplexDbl> rsqrt() const {+    return sqrt().reciprocal();+  }++  static Vec256<ComplexDbl> horizontal_add(+      Vec256<ComplexDbl>& first,+      Vec256<ComplexDbl>& second) {+    auto first_perm = first.el_swapped(); // 2perm+    auto second_perm = second.el_swapped(); // 2perm+    // summ+    auto first_ret = first + first_perm; // 2add+    auto second_ret = second + second_perm; // 2 add+    // now lets choose evens+    return el_mergee(first_ret, second_ret); // 2 mergee's+  }++  static Vec256<ComplexDbl> horizontal_sub(+      Vec256<ComplexDbl>& first,+      Vec256<ComplexDbl>& second) {+    // we will simulate it differently with 6 instructions total+    // lets permute second so that we can add it getting horizontall sums+    auto first_perm = first.el_swapped(); // 2perm+    auto second_perm = second.el_swapped(); // 2perm+    // summ+    auto first_ret = first - first_perm; // 2sub+    auto second_ret = second - second_perm; // 2 sub+    // now lets choose evens+    return el_mergee(first_ret, second_ret); // 2 mergee's+  }++  Vec256<ComplexDbl> inline operator*(const Vec256<ComplexDbl>& b) const {+    //(a + bi)  * (c + di) = (ac - bd) + (ad + bc)i+#if 1+    // this is more vsx friendly than simulating horizontall from x86

+#pragma once++#include <ATen/cpu/vec256/intrinsics.h>+#include <ATen/cpu/vec256/vec256_base.h>+#include <ATen/cpu/vec256/vsx/vsx_helpers.h>+#include <ATen/cpu/vec256/vsx/vec256_double_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_float_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_int16_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_int32_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_int64_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_qint32_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_qint8_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_quint8_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_complex_float_vsx.h>+#include <ATen/cpu/vec256/vsx/vec256_complex_double_vsx.h>+namespace at {+namespace vec256 {++namespace {++DEFINE_CLAMP_FUNCS(c10::quint8)+DEFINE_CLAMP_FUNCS(c10::qint8)+DEFINE_CLAMP_FUNCS(c10::qint32)+DEFINE_CLAMP_FUNCS(int16_t)+DEFINE_CLAMP_FUNCS(int32_t)+DEFINE_CLAMP_FUNCS(int64_t)+DEFINE_CLAMP_FUNCS(float)+DEFINE_CLAMP_FUNCS(double)++template <>+Vec256<double> inline __inline_attrs fmadd(+    const Vec256<double>& a,+    const Vec256<double>& b,+    const Vec256<double>& c) {+  return Vec256<double>{+      vec_madd(a.vec0(), b.vec0(), c.vec0()),+      vec_madd(a.vec1(), b.vec1(), c.vec1())};+}++template <>+Vec256<int64_t> inline __inline_attrs fmadd(+    const Vec256<int64_t>& a,+    const Vec256<int64_t>& b,+    const Vec256<int64_t>& c) {+  return Vec256<int64_t>{+      a.vec0() * b.vec0() + c.vec0(), a.vec1() * b.vec1() + c.vec1()};+}+template <>+Vec256<int32_t> inline __inline_attrs fmadd(+    const Vec256<int32_t>& a,+    const Vec256<int32_t>& b,+    const Vec256<int32_t>& c) {+  return Vec256<int32_t>{+      a.vec0() * b.vec0() + c.vec0(), a.vec1() * b.vec1() + c.vec1()};+}+template <>+Vec256<int16_t> inline __inline_attrs fmadd(+    const Vec256<int16_t>& a,+    const Vec256<int16_t>& b,+    const Vec256<int16_t>& c) {+  return Vec256<int16_t>{+      a.vec0() * b.vec0() + c.vec0(), a.vec1() * b.vec1() + c.vec1()};+}++DEFINE_REINTERPRET_CAST_TO_ALL_FUNCS(float)+DEFINE_REINTERPRET_CAST_TO_ALL_FUNCS(double)+DEFINE_REINTERPRET_CAST_TO_ALL_FUNCS(int64_t)+DEFINE_REINTERPRET_CAST_TO_ALL_FUNCS(int32_t)+DEFINE_REINTERPRET_CAST_TO_ALL_FUNCS(int16_t)++template <>+Vec256<int64_t> inline __inline_attrs convert_to_int_of_same_size<double>(+    const Vec256<double>& src) {+  return Vec256<int64_t>{vec_signed(src.vec0()), vec_signed(src.vec1())};+}++template <>+Vec256<int32_t> inline __inline_attrs convert_to_int_of_same_size<float>(+    const Vec256<float>& src) {+  return Vec256<int32_t>{vec_signed(src.vec0()), vec_signed(src.vec1())};+}++template <>+inline void convert(const int32_t* src, float* dst, int64_t n) {+  // int32_t and float have same size+  size_t N = n;+  size_t NE = N & (~(Vec256<int32_t>::size() - 1));+  for (size_t i = 0; i < NE; i += Vec256<int32_t>::size()) {+    const int32_t* src_a = src + i;+    float* dst_a = dst + i;+    __vi input_vec0 = vec_vsx_ld(offset0, reinterpret_cast<const __vi*>(src_a));+    __vi input_vec1 =+        vec_vsx_ld(offset16, reinterpret_cast<const __vi*>(src_a));+    vec_vsx_st(vec_float(input_vec0), offset0, dst_a);