<commit_before>#include "mipp.h"

template <typename T>
class Reg;

template <typename T> inline Reg<T> add(const Reg<T> v1, const Reg<T> v2);
template <typename T> inline Reg<T> sub(const Reg<T> v1, const Reg<T> v2);
template <typename T> inline Reg<T> mul(const Reg<T> v1, const Reg<T> v2);
template <typename T> inline Reg<T> div(const Reg<T> v1, const Reg<T> v2);
template <typename T> inline Reg<T> min(const Reg<T> v1, const Reg<T> v2);
template <typename T> inline Reg<T> max(const Reg<T> v1, const Reg<T> v2);

template <typename T>
class Reg_2;

template <typename T>
class Regx2;

template <typename T>
class Reg
{
public:
#ifndef MIPP_NO_INTRINSICS
	reg r;
#else
	T r;
#endif

#ifndef MIPP_NO_INTRINSICS
	Reg(              )                          {}
	Reg(const reg r   ) : r(r)                   {}
	Reg(const T   val ) : r(mipp::set1 <T>(val)) {}

#ifdef MIPP_ALIGNED_LOADS
	Reg(const T  *data) : r(mipp::load <T>(data)){}
#else
	Reg(const T  *data) : r(mipp::loadu<T>(data)){}
#endif

	Reg(const std::initializer_list<T> &l)
	{
		if (l.size() >= (unsigned)mipp::nElReg<T>())
			r = mipp::loadu<T>(l.begin());
		else
		{
			auto vec = mipp::vector<T>(mipp::nElReg<T>());
			vec = l;
			r = mipp::load<T>(vec.data());
		}
	}

	~Reg() {}
#else
	Reg(             )              {}
	Reg(const T  val ) : r(val)     {}
	Reg(const T *data) : r(data[0]) {}

	Reg(const std::initializer_list<T> &l)
	{
		auto vec = mipp::vector<T>(mipp::nElReg<T>());
		vec = l;
		r = vec[0];
	}

	~Reg() {}
#endif

#ifndef MIPP_NO_INTRINSICS
	static inline Reg<T> cmask (const int mask[nElReg<T>()  ]) { return mipp::cmask <T>(mask); }
	static inline Reg<T> cmask2(const int mask[nElReg<T>()/2]) { return mipp::cmask2<T>(mask); }
#else
	static inline Reg<T> cmask (const int mask[nElReg<T>()  ]) { return Reg<T>((T)0);          }
	static inline Reg<T> cmask2(const int mask[nElReg<T>()/2]) { return Reg<T>((T)0);          }
#endif

	static inline void transpose(Reg<T> regs[nElReg<T>()])
	{
#ifndef MIPP_NO_INTRINSICS
		reg rs[nElReg<T>()];
		for (auto i = 0; i < nElReg<T>(); i++) rs[i] = regs[i].r;
		mipp::transpose<T>(rs);
		for (auto i = 0; i < nElReg<T>(); i++) regs[i].r = rs[i];
#endif
	}

	static inline void transpose8x8(Reg<T> regs[8])
	{
#ifndef MIPP_NO_INTRINSICS
		reg rs[8];
		for (auto i = 0; i < 8; i++) rs[i] = regs[i].r;
		mipp::transpose8x8<T>(rs);
		for (auto i = 0; i < 8; i++) regs[i].r = rs[i];
#else
		std::cerr << "\"transpose8x8\" static method is a non-sense in sequential mode, exiting." << std::endl;
		exit(EXIT_FAILURE);
#endif
	}

	static inline void transpose2(Reg<T> regs[nElReg<T>()/2])
	{
#ifndef MIPP_NO_INTRINSICS
		reg rs[nElReg<T>()/2];
		for (auto i = 0; i < nElReg<T>()/2; i++) rs[i] = regs[i].r;
		mipp::transpose2<T>(rs);
		for (auto i = 0; i < nElReg<T>()/2; i++) regs[i].r = rs[i];
#else
		std::cerr << "\"transpose2\" static method is a non-sense in sequential mode, exiting." << std::endl;
		exit(EXIT_FAILURE);
#endif
	}

	static inline void transpose28x8(Reg<T> regs[8])
	{
#ifndef MIPP_NO_INTRINSICS
		reg rs[8];
		for (auto i = 0; i < 8; i++) rs[i] = regs[i].r;
		mipp::transpose28x8<T>(rs);
		for (auto i = 0; i < 8; i++) regs[i].r = rs[i];
#else
		std::cerr << "\"transpose28x8\" static method is a non-sense in sequential mode, exiting." << std::endl;
		exit(EXIT_FAILURE);
#endif
	}

#ifndef MIPP_NO_INTRINSICS
	inline void     set0         (               )                        { r = mipp::set0<T>();                          }
	inline void     set1         (const T val    )                        { r = mipp::set1<T>(val);                       }
	inline void     load         (const T* data  )                        { r = mipp::load<T>(data);                      }
	inline void     loadu        (const T* data  )                        { r = mipp::loadu<T>(data);                     }
	inline void     store        (T* data        )                  const { mipp::store<T>(data, r);                      }
	inline void     storeu       (T* data        )                  const { mipp::storeu<T>(data, r);                     }
	inline Reg_2<T> low          (               )                  const { return mipp::low <T>(r);                      }
	inline Reg_2<T> high         (               )                  const { return mipp::high<T>(r);                      }
#else
	inline void     set0         (               )                        { r = 0;                                        }
	inline void     set1         (const T val    )                        { r = val;                                      }
	inline void     load         (const T* data  )                        { r = data[0];                                  }
	inline void     loadu        (const T* data  )                        { r = data[0];                                  }
	inline void     store        (T* data        )                  const { data[0] = r;                                  }
	inline void     storeu       (T* data        )                  const { data[0] = r;                                  }
	inline Reg_2<T> low          (               )                  const { return r;                                     }
	inline Reg_2<T> high         (               )                  const { return r;                                     }
#endif

#ifndef MIPP_NO_INTRINSICS
	inline Reg<T>   shuff        (const Reg<T> v_shu)               const { return mipp::shuff        <T>(r, v_shu.r);    }
	inline Reg<T>   shuff2       (const Reg<T> v_shu)               const { return mipp::shuff2       <T>(r, v_shu.r);    }
	inline Reg<T>   interleavelo (const Reg<T> v)                   const { return mipp::interleavelo <T>(r, v.r);        }
	inline Reg<T>   interleavehi (const Reg<T> v)                   const { return mipp::interleavehi <T>(r, v.r);        }
	inline Reg<T>   interleavelo2(const Reg<T> v)                   const { return mipp::interleavelo2<T>(r, v.r);        }
	inline Reg<T>   interleavehi2(const Reg<T> v)                   const { return mipp::interleavehi2<T>(r, v.r);        }
	inline Regx2<T> interleave   (const Reg<T> v)                   const { return mipp::interleave   <T>(r, v.r);        }
	inline Regx2<T> interleave2  (const Reg<T> v)                   const { return mipp::interleave2  <T>(r, v.r);        }
	inline Reg<T>   interleave   ()                                 const { return mipp::interleave   <T>(r);             }
	inline Regx2<T> interleavex2 (const Reg<T> v)                   const { return mipp::interleavex2 <T>(r, v.r);        }
	inline Reg<T>   interleavex4 ()                                 const { return mipp::interleavex4 <T>(r);             }
	inline Reg<T>   interleavex16()                                 const { return mipp::interleavex16<T>(r);             }
	inline Reg<T>   andb         (const Reg<T> v)                   const { return mipp::andb         <T>(r, v.r);        }
	inline Reg<T>   andnb        (const Reg<T> v)                   const { return mipp::andnb        <T>(r, v.r);        }
	inline Reg<T>   notb         ()                                 const { return mipp::notb         <T>(r);             }
	inline Reg<T>   orb          (const Reg<T> v)                   const { return mipp::orb          <T>(r, v.r);        }
	inline Reg<T>   xorb         (const Reg<T> v)                   const { return mipp::xorb         <T>(r, v.r);        }
	inline Reg<T>   lshift       (const int n)                      const { return mipp::lshift       <T>(r, n);          }
	inline Reg<T>   rshift       (const int n)                      const { return mipp::rshift       <T>(r, n);          }
	inline Reg<T>   cmpeq        (const Reg<T> v)                   const { return mipp::cmpeq        <T>(r, v.r);        }
	inline Reg<T>   cmpneq       (const Reg<T> v)                   const { return mipp::cmpneq       <T>(r, v.r);        }
	inline Reg<T>   cmplt        (const Reg<T> v)                   const { return mipp::cmplt        <T>(r, v.r);        }
	inline Reg<T>   cmple        (const Reg<T> v)                   const { return mipp::cmple        <T>(r, v.r);        }
	inline Reg<T>   cmpgt        (const Reg<T> v)                   const { return mipp::cmpgt        <T>(r, v.r);        }
	inline Reg<T>   cmpge        (const Reg<T> v)                   const { return mipp::cmpge        <T>(r, v.r);        }
	inline Reg<T>   add          (const Reg<T> v)                   const { return mipp::add          <T>(r, v.r);        }
	inline Reg<T>   sub          (const Reg<T> v)                   const { return mipp::sub          <T>(r, v.r);        }
	inline Reg<T>   mul          (const Reg<T> v)                   const { return mipp::mul          <T>(r, v.r);        }
	inline Reg<T>   div          (const Reg<T> v)                   const { return mipp::div          <T>(r, v.r);        }
	inline Reg<T>   min          (const Reg<T> v)                   const { return mipp::min          <T>(r, v.r);        }
	inline Reg<T>   max          (const Reg<T> v)                   const { return mipp::max          <T>(r, v.r);        }
	inline Reg<T>   sign         ()                                 const { return mipp::sign         <T>(r);             }
	inline Reg<T>   sign         (const Reg<T> v)                   const { return mipp::sign         <T>(r, v.r);        }
	inline Reg<T>   neg          (const Reg<T> v)                   const { return mipp::neg          <T>(r, v.r);        }
	inline Reg<T>   abs          ()                                 const { return mipp::abs          <T>(r);             }
	inline Reg<T>   sqrt         ()                                 const { return mipp::sqrt         <T>(r);             }
	inline Reg<T>   rsqrt        ()                                 const { return mipp::rsqrt        <T>(r);             }
	inline Reg<T>   log          ()                                 const { return mipp::log          <T>(r);             }
	inline Reg<T>   exp          ()                                 const { return mipp::exp          <T>(r);             }
	inline Reg<T>   sin          ()                                 const { return mipp::sin          <T>(r);             }
	inline Reg<T>   cos          ()                                 const { return mipp::cos          <T>(r);             }
	inline void     sincos       (      Reg<T> &s,       Reg<T> &c) const { return mipp::sincos       <T>(r,  s.r,  c.r); }
	inline Reg<T>   fmadd        (const Reg<T> v1, const Reg<T> v2) const { return mipp::fmadd        <T>(r, v1.r, v2.r); }
	inline Reg<T>   fnmadd       (const Reg<T> v1, const Reg<T> v2) const { return mipp::fnmadd       <T>(r, v1.r, v2.r); }
	inline Reg<T>   fmsub        (const Reg<T> v1, const Reg<T> v2) const { return mipp::fmsub        <T>(r, v1.r, v2.r); }
	inline Reg<T>   rot          ()                                 const { return mipp::rot          <T>(r);             }
	inline Reg<T>   rotr         ()                                 const { return mipp::rotr         <T>(r);             }
	inline Reg<T>   div2         ()                                 const { return mipp::div2         <T>(r);             }
	inline Reg<T>   div4         ()                                 const { return mipp::div4         <T>(r);             }
	inline Reg<T>   sat          (T min, T max)                     const { return mipp::sat          <T>(r, min, max);   }
	inline Reg<T>   round        ()                                 const { return mipp::round        <T>(r);             }
#else
	inline Reg<T>   shuff        (const Reg<T> v_shu)               const { return *this;                                 }
	inline Reg<T>   shuff2       (const Reg<T> v_shu)               const { return *this;                                 }
	inline Reg<T>   interleavelo (const Reg<T> v)                   const { return *this;                                 }
	inline Reg<T>   interleavehi (const Reg<T> v)                   const { return *this;                                 }<commit_msg>Fix bad sincos implem.<commit_after>#include "mipp.h"

template <typename T>
class Reg;

template <typename T> inline Reg<T> add(const Reg<T> v1, const Reg<T> v2);
template <typename T> inline Reg<T> sub(const Reg<T> v1, const Reg<T> v2);
template <typename T> inline Reg<T> mul(const Reg<T> v1, const Reg<T> v2);
template <typename T> inline Reg<T> div(const Reg<T> v1, const Reg<T> v2);
template <typename T> inline Reg<T> min(const Reg<T> v1, const Reg<T> v2);
template <typename T> inline Reg<T> max(const Reg<T> v1, const Reg<T> v2);

template <typename T>
class Reg_2;

template <typename T>
class Regx2;

template <typename T>
class Reg
{
public:
#ifndef MIPP_NO_INTRINSICS
	reg r;
#else
	T r;
#endif

#ifndef MIPP_NO_INTRINSICS
	Reg(              )                          {}
	Reg(const reg r   ) : r(r)                   {}
	Reg(const T   val ) : r(mipp::set1 <T>(val)) {}

#ifdef MIPP_ALIGNED_LOADS
	Reg(const T  *data) : r(mipp::load <T>(data)){}
#else
	Reg(const T  *data) : r(mipp::loadu<T>(data)){}
#endif

	Reg(const std::initializer_list<T> &l)
	{
		if (l.size() >= (unsigned)mipp::nElReg<T>())
			r = mipp::loadu<T>(l.begin());
		else
		{
			auto vec = mipp::vector<T>(mipp::nElReg<T>());
			vec = l;
			r = mipp::load<T>(vec.data());
		}
	}

	~Reg() {}
#else
	Reg(             )              {}
	Reg(const T  val ) : r(val)     {}
	Reg(const T *data) : r(data[0]) {}

	Reg(const std::initializer_list<T> &l)
	{
		auto vec = mipp::vector<T>(mipp::nElReg<T>());
		vec = l;
		r = vec[0];
	}

	~Reg() {}
#endif

#ifndef MIPP_NO_INTRINSICS
	static inline Reg<T> cmask (const int mask[nElReg<T>()  ]) { return mipp::cmask <T>(mask); }
	static inline Reg<T> cmask2(const int mask[nElReg<T>()/2]) { return mipp::cmask2<T>(mask); }
#else
	static inline Reg<T> cmask (const int mask[nElReg<T>()  ]) { return Reg<T>((T)0);          }
	static inline Reg<T> cmask2(const int mask[nElReg<T>()/2]) { return Reg<T>((T)0);          }
#endif

	static inline void transpose(Reg<T> regs[nElReg<T>()])
	{
#ifndef MIPP_NO_INTRINSICS
		reg rs[nElReg<T>()];
		for (auto i = 0; i < nElReg<T>(); i++) rs[i] = regs[i].r;
		mipp::transpose<T>(rs);
		for (auto i = 0; i < nElReg<T>(); i++) regs[i].r = rs[i];
#endif
	}

	static inline void transpose8x8(Reg<T> regs[8])
	{
#ifndef MIPP_NO_INTRINSICS
		reg rs[8];
		for (auto i = 0; i < 8; i++) rs[i] = regs[i].r;
		mipp::transpose8x8<T>(rs);
		for (auto i = 0; i < 8; i++) regs[i].r = rs[i];
#else
		std::cerr << "\"transpose8x8\" static method is a non-sense in sequential mode, exiting." << std::endl;
		exit(EXIT_FAILURE);
#endif
	}

	static inline void transpose2(Reg<T> regs[nElReg<T>()/2])
	{
#ifndef MIPP_NO_INTRINSICS
		reg rs[nElReg<T>()/2];
		for (auto i = 0; i < nElReg<T>()/2; i++) rs[i] = regs[i].r;
		mipp::transpose2<T>(rs);
		for (auto i = 0; i < nElReg<T>()/2; i++) regs[i].r = rs[i];
#else
		std::cerr << "\"transpose2\" static method is a non-sense in sequential mode, exiting." << std::endl;
		exit(EXIT_FAILURE);
#endif
	}

	static inline void transpose28x8(Reg<T> regs[8])
	{
#ifndef MIPP_NO_INTRINSICS
		reg rs[8];
		for (auto i = 0; i < 8; i++) rs[i] = regs[i].r;
		mipp::transpose28x8<T>(rs);
		for (auto i = 0; i < 8; i++) regs[i].r = rs[i];
#else
		std::cerr << "\"transpose28x8\" static method is a non-sense in sequential mode, exiting." << std::endl;
		exit(EXIT_FAILURE);
#endif
	}

#ifndef MIPP_NO_INTRINSICS
	inline void     set0         (               )                        { r = mipp::set0<T>();                          }
	inline void     set1         (const T val    )                        { r = mipp::set1<T>(val);                       }
	inline void     load         (const T* data  )                        { r = mipp::load<T>(data);                      }
	inline void     loadu        (const T* data  )                        { r = mipp::loadu<T>(data);                     }
	inline void     store        (T* data        )                  const { mipp::store<T>(data, r);                      }
	inline void     storeu       (T* data        )                  const { mipp::storeu<T>(data, r);                     }
	inline Reg_2<T> low          (               )                  const { return mipp::low <T>(r);                      }
	inline Reg_2<T> high         (               )                  const { return mipp::high<T>(r);                      }
#else
	inline void     set0         (               )                        { r = 0;                                        }
	inline void     set1         (const T val    )                        { r = val;                                      }
	inline void     load         (const T* data  )                        { r = data[0];                                  }
	inline void     loadu        (const T* data  )                        { r = data[0];                                  }
	inline void     store        (T* data        )                  const { data[0] = r;                                  }
	inline void     storeu       (T* data        )                  const { data[0] = r;                                  }
	inline Reg_2<T> low          (               )                  const { return r;                                     }
	inline Reg_2<T> high         (               )                  const { return r;                                     }
#endif

#ifndef MIPP_NO_INTRINSICS
	inline Reg<T>   shuff        (const Reg<T> v_shu)               const { return mipp::shuff        <T>(r, v_shu.r);    }
	inline Reg<T>   shuff2       (const Reg<T> v_shu)               const { return mipp::shuff2       <T>(r, v_shu.r);    }
	inline Reg<T>   interleavelo (const Reg<T> v)                   const { return mipp::interleavelo <T>(r, v.r);        }
	inline Reg<T>   interleavehi (const Reg<T> v)                   const { return mipp::interleavehi <T>(r, v.r);        }
	inline Reg<T>   interleavelo2(const Reg<T> v)                   const { return mipp::interleavelo2<T>(r, v.r);        }
	inline Reg<T>   interleavehi2(const Reg<T> v)                   const { return mipp::interleavehi2<T>(r, v.r);        }
	inline Regx2<T> interleave   (const Reg<T> v)                   const { return mipp::interleave   <T>(r, v.r);        }
	inline Regx2<T> interleave2  (const Reg<T> v)                   const { return mipp::interleave2  <T>(r, v.r);        }
	inline Reg<T>   interleave   ()                                 const { return mipp::interleave   <T>(r);             }
	inline Regx2<T> interleavex2 (const Reg<T> v)                   const { return mipp::interleavex2 <T>(r, v.r);        }
	inline Reg<T>   interleavex4 ()                                 const { return mipp::interleavex4 <T>(r);             }
	inline Reg<T>   interleavex16()                                 const { return mipp::interleavex16<T>(r);             }
	inline Reg<T>   andb         (const Reg<T> v)                   const { return mipp::andb         <T>(r, v.r);        }
	inline Reg<T>   andnb        (const Reg<T> v)                   const { return mipp::andnb        <T>(r, v.r);        }
	inline Reg<T>   notb         ()                                 const { return mipp::notb         <T>(r);             }
	inline Reg<T>   orb          (const Reg<T> v)                   const { return mipp::orb          <T>(r, v.r);        }
	inline Reg<T>   xorb         (const Reg<T> v)                   const { return mipp::xorb         <T>(r, v.r);        }
	inline Reg<T>   lshift       (const int n)                      const { return mipp::lshift       <T>(r, n);          }
	inline Reg<T>   rshift       (const int n)                      const { return mipp::rshift       <T>(r, n);          }
	inline Reg<T>   cmpeq        (const Reg<T> v)                   const { return mipp::cmpeq        <T>(r, v.r);        }
	inline Reg<T>   cmpneq       (const Reg<T> v)                   const { return mipp::cmpneq       <T>(r, v.r);        }
	inline Reg<T>   cmplt        (const Reg<T> v)                   const { return mipp::cmplt        <T>(r, v.r);        }
	inline Reg<T>   cmple        (const Reg<T> v)                   const { return mipp::cmple        <T>(r, v.r);        }
	inline Reg<T>   cmpgt        (const Reg<T> v)                   const { return mipp::cmpgt        <T>(r, v.r);        }
	inline Reg<T>   cmpge        (const Reg<T> v)                   const { return mipp::cmpge        <T>(r, v.r);        }
	inline Reg<T>   add          (const Reg<T> v)                   const { return mipp::add          <T>(r, v.r);        }
	inline Reg<T>   sub          (const Reg<T> v)                   const { return mipp::sub          <T>(r, v.r);        }
	inline Reg<T>   mul          (const Reg<T> v)                   const { return mipp::mul          <T>(r, v.r);        }
	inline Reg<T>   div          (const Reg<T> v)                   const { return mipp::div          <T>(r, v.r);        }
	inline Reg<T>   min          (const Reg<T> v)                   const { return mipp::min          <T>(r, v.r);        }
	inline Reg<T>   max          (const Reg<T> v)                   const { return mipp::max          <T>(r, v.r);        }
	inline Reg<T>   sign         ()                                 const { return mipp::sign         <T>(r);             }
	inline Reg<T>   sign         (const Reg<T> v)                   const { return mipp::sign         <T>(r, v.r);        }
	inline Reg<T>   neg          (const Reg<T> v)                   const { return mipp::neg          <T>(r, v.r);        }
	inline Reg<T>   abs          ()                                 const { return mipp::abs          <T>(r);             }
	inline Reg<T>   sqrt         ()                                 const { return mipp::sqrt         <T>(r);             }
	inline Reg<T>   rsqrt        ()                                 const { return mipp::rsqrt        <T>(r);             }
	inline Reg<T>   log          ()                                 const { return mipp::log          <T>(r);             }
	inline Reg<T>   exp          ()                                 const { return mipp::exp          <T>(r);             }
	inline Reg<T>   sin          ()                                 const { return mipp::sin          <T>(r);             }
	inline Reg<T>   cos          ()                                 const { return mipp::cos          <T>(r);             }
	inline void     sincos       (      Reg<T> &s,       Reg<T> &c) const {        mipp::sincos       <T>(r,  s.r,  c.r); }
	inline Reg<T>   fmadd        (const Reg<T> v1, const Reg<T> v2) const { return mipp::fmadd        <T>(r, v1.r, v2.r); }
	inline Reg<T>   fnmadd       (const Reg<T> v1, const Reg<T> v2) const { return mipp::fnmadd       <T>(r, v1.r, v2.r); }
	inline Reg<T>   fmsub        (const Reg<T> v1, const Reg<T> v2) const { return mipp::fmsub        <T>(r, v1.r, v2.r); }
	inline Reg<T>   rot          ()                                 const { return mipp::rot          <T>(r);             }
	inline Reg<T>   rotr         ()                                 const { return mipp::rotr         <T>(r);             }
	inline Reg<T>   div2         ()                                 const { return mipp::div2         <T>(r);             }
	inline Reg<T>   div4         ()                                 const { return mipp::div4         <T>(r);             }
	inline Reg<T>   sat          (T min, T max)                     const { return mipp::sat          <T>(r, min, max);   }
	inline Reg<T>   round        ()                                 const { return mipp::round        <T>(r);             }
#else
	inline Reg<T>   shuff        (const Reg<T> v_shu)               const { return *this;                                 }
	inline Reg<T>   shuff2       (const Reg<T> v_shu)               const { return *this;                                 }
	inline Reg<T>   interleavelo (const Reg<T> v)                   const { return *this;                                 }
	inline Reg<T>   interleavehi (const Reg<T> v)                   const { return *this;                                 }
{'fraction_non_alphanumeric': 0.14014568158168575, 'fraction_numerical': 0.009406867845993757, 'mean_word_length': 1.3130836622701454, 'pattern_counts': {'":': 0, '<': 491, '<?xml version=': 0, '>': 453, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 123, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '6910561', 'n_tokens_mistral': 8149, 'n_tokens_neox': 7862, 'n_words': 2042}