tomoto 0.1.0

data/vendor/tomotopy/src/Utils/Utils.hpp

@@ -0,0 +1,337 @@
+#pragma once
+#include <cassert>
+#include <vector>
+#include <functional>
+#include <typeinfo>
+#include <algorithm>
+#include <memory>
+#include <mutex>
+#include <iterator>
+
+namespace tomoto
+{
+	template<typename T, typename... Args, 
+		typename std::enable_if<!std::is_array<T>::value, int>::type = 0>
+	std::unique_ptr<T> make_unique(Args&&... args)
+	{
+		return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+	}
+
+	template<typename T,
+		typename std::enable_if<std::is_array<T>::value, int>::type = 0>
+	std::unique_ptr<T> make_unique(size_t size)
+	{
+		return std::unique_ptr<T>(new typename std::remove_extent<T>::type [size]);
+	}
+
+	template<typename T>
+	constexpr T * as_mutable(const T * value) noexcept {
+		return const_cast<T *>(value);
+	}
+
+	template<bool _lock>
+	class OptionalLock : public std::lock_guard<std::mutex>
+	{
+	public:
+		using std::lock_guard<std::mutex>::lock_guard;
+	};
+
+	template<>
+	class OptionalLock<false>
+	{
+	public:
+		OptionalLock(const std::mutex& mtx)
+		{}
+	};
+
+	template<bool _Dec, typename _Ty>
+	struct CntUpdater
+	{
+		inline _Ty operator()(_Ty& val, _Ty inc)
+		{
+			return val += inc;
+		}
+	};
+
+	template<typename _Ty>
+	struct CntUpdater<true, _Ty>
+	{
+		inline _Ty operator()(_Ty& val, _Ty inc)
+		{
+			return val = std::max(val + inc, (_Ty)0);
+		}
+	};
+
+	template<bool _Dec, typename _Ty> _Ty updateCnt(_Ty& val, _Ty inc)
+	{
+		auto ret = CntUpdater<_Dec, _Ty>{}(val, inc);
+		assert(ret >= 0);
+		return ret;
+	}
+
+	template<class UnaryFunction>
+	UnaryFunction forRandom(size_t N, size_t seed, UnaryFunction f)
+	{
+		static size_t primes[16] = {
+			65537, 65539, 65543, 65551, 65557, 65563,
+			65579, 65581, 65587, 65599, 65609, 65617,
+			65629, 65633, 65647, 65651
+		};
+		if (!N) return f;
+		size_t P = primes[seed & 0xF];
+		if (N % P == 0)
+		{
+			P = primes[(seed + 1) & 0xF];
+			if (N % P == 0) P = primes[(seed + 2) & 0xF];
+			if (N % P == 0) P = primes[(seed + 3) & 0xF];
+		}
+		P %= N;
+		for (size_t i = 0; i < N; ++i) {
+			f(((i + seed) * P) % N);
+		}
+		return f;
+	}
+
+	template<class RandomIt, class UnaryFunction>
+	UnaryFunction forEachRandom(RandomIt first, RandomIt last, size_t seed, UnaryFunction f)
+	{
+		static size_t primes[16] = {
+			65537, 65539, 65543, 65551, 65557, 65563,
+			65579, 65581, 65587, 65599, 65609, 65617,
+			65629, 65633, 65647, 65651
+		};
+
+		const size_t N = std::distance(first, last);
+		if (!N) return f;
+		size_t P = primes[seed & 0xF];
+		if (N % P == 0)
+		{
+			P = primes[(seed + 1) & 0xF];
+			if (N % P == 0) P = primes[(seed + 2) & 0xF];
+			if (N % P == 0) P = primes[(seed + 3) & 0xF];
+		}
+		P %= N;
+		for (size_t i = 0; i < N; ++i) {
+			f(first[((i + seed) * P) % N]);
+		}
+		return f;
+	}
+
+	template<class _Cont, class _Ty>
+	size_t insertIntoEmpty(_Cont& cont, _Ty&& e)
+	{
+		size_t pos = 0;
+		for (auto& c : cont)
+		{
+			if (!(bool)c)
+			{
+				c = e;
+				return pos;
+			}
+			++pos;
+		}
+		cont.emplace_back(e);
+		return pos;
+	}
+
+	/*
+	* _Container src: (in/out) container to be sorted
+	* vector<integer> order: (out) a vector mapping old idx to new idx (order[oldIdx] => newIdx)
+	* _Less cmp: (in) comparator
+	*/
+	template<typename _Container, typename _OrderType = uint32_t, typename _Less = std::less<typename _Container::value_type>>
+	void sortAndWriteOrder(_Container& src, std::vector<_OrderType>& order, size_t rotate = 0, _Less cmp = _Less{})
+	{
+		typedef std::pair<typename _Container::value_type, _OrderType> voPair_t;
+		std::vector<voPair_t> pv(src.size());
+		for (_OrderType i = 0; i < src.size(); ++i)
+		{
+			pv[i] = std::make_pair(src[i], i);
+		}
+
+		std::stable_sort(pv.begin(), pv.end(), [&cmp](const voPair_t& a, const voPair_t& b)
+		{
+			return cmp(a.first, b.first);
+		});
+		if (rotate) std::rotate(pv.begin(), pv.begin() + rotate, pv.end());
+		order = std::vector<_OrderType>(src.size());
+		for (size_t i = 0; i < src.size(); ++i)
+		{
+			src[i] = pv[i].first;
+			order[pv[i].second] = i;
+		}
+	}
+
+	template <typename _BaseIter>
+	struct FilteredIter : _BaseIter
+	{
+		using filterTy = std::function<bool(const typename std::iterator_traits<_BaseIter>::value_type&)>;
+
+		FilteredIter() = default;
+		FilteredIter(filterTy filter, _BaseIter base, _BaseIter end = {})
+			: _BaseIter(base), _filter(filter), _end(end)
+		{
+			while (*this != _end && !_filter(**this)) {
+				++*this;
+			}
+		}
+
+		FilteredIter& operator++()
+		{
+			do
+			{
+				_BaseIter::operator++();
+			} while (*this != _end && !_filter(**this));
+			return *this;
+		}
+
+		FilteredIter operator++(int)
+		{
+			FilteredIter copy = *this;
+			++*this;
+			return copy;
+		}
+
+	private:
+		filterTy _filter;
+		_BaseIter _end;
+	};
+
+	template <typename _BaseIter>
+	FilteredIter<_BaseIter> makeFilteredIter(
+		typename FilteredIter<_BaseIter>::filterTy filter,
+		_BaseIter base, _BaseIter end = {})
+	{
+		return { filter, base, end };
+	}
+
+	template <typename _UnaryFunc, typename _Iterator>
+	class TransformIter
+	{
+	private:
+		_Iterator i;
+		_UnaryFunc f;
+	public:
+		using reference = typename std::result_of<
+			const _UnaryFunc(typename std::iterator_traits<_Iterator>::reference)
+		>::type;
+		using value_type = reference;
+
+		using pointer = void;
+		using iterator_category = typename std::iterator_traits<_Iterator>::iterator_category;
+		using difference_type = typename std::iterator_traits<_Iterator>::difference_type;
+
+		TransformIter(const _Iterator& _iter = {}, _UnaryFunc _f = {})
+			: i(_iter), f(_f)
+		{}
+		
+		reference operator*()
+		{
+			return f(*i);
+		}
+
+		const reference operator*() const
+		{
+			return f(*i);
+		}
+
+		reference operator[](std::size_t idx)
+		{
+			return f(i[idx]);
+		}
+
+		const reference operator[](std::size_t idx) const
+		{
+			return f(i[idx]);
+		}
+
+		TransformIter& operator++()
+		{
+			++i;
+			return *this;
+		}
+
+		TransformIter& operator++(int)
+		{
+			auto c = *this;
+			++i;
+			return c;
+		}
+
+		TransformIter& operator--()
+		{
+			--i;
+			return *this;
+		}
+
+		TransformIter& operator--(int)
+		{
+			auto c = *this;
+			--i;
+			return c;
+		}
+
+		TransformIter operator+(int n) const
+		{
+			return { f, i + n };
+		}
+
+		TransformIter operator-(int n) const
+		{
+			return { f, i - n };
+		}
+
+		TransformIter& operator+=(int n)
+		{
+			i += n;
+			return *this;
+		}
+
+		TransformIter& operator-=(int n)
+		{
+			i -= n;
+			return *this;
+		}
+
+		typename std::iterator_traits<_Iterator>::difference_type operator-(const TransformIter& o) const
+		{
+			return i - o.i;
+		}
+
+		bool operator==(const TransformIter& o) const
+		{
+			return i == o.i;
+		}
+
+		bool operator!=(const TransformIter& o) const
+		{
+			return i != o.i;
+		}
+
+		bool operator<(const TransformIter& o) const
+		{
+			return i < o.i;
+		}
+
+		bool operator>(const TransformIter& o) const
+		{
+			return i > o.i;
+		}
+
+		bool operator<=(const TransformIter& o) const
+		{
+			return i <= o.i;
+		}
+
+		bool operator>=(const TransformIter& o) const
+		{
+			return i >= o.i;
+		}
+	};
+
+	template <typename _UnaryFunc, typename _Iterator> 
+	TransformIter<_UnaryFunc, _Iterator> makeTransformIter(const _Iterator& iter, _UnaryFunc f)
+	{
+		return { iter, f };
+	}
+}

data/vendor/tomotopy/src/Utils/avx_gamma.h

@@ -0,0 +1,46 @@
+#pragma once
+#include "avx_mathfun.h"
+
+// approximation : lgamma(z) ~= (z+2.5)ln(z+3) - z - 3 + 0.5 ln (2pi) + 1/12/(z + 3) - ln (z(z+1)(z+2))
+inline __m256 lgamma_ps(__m256 x)
+{
+	__m256 x_3 = _mm256_add_ps(x, _mm256_set1_ps(3));
+	__m256 ret = _mm256_mul_ps(_mm256_add_ps(x_3, _mm256_set1_ps(-0.5f)), log_ps(x_3));
+	ret = _mm256_sub_ps(ret, x_3);
+	ret = _mm256_add_ps(ret, _mm256_set1_ps(0.91893853f));
+	ret = _mm256_add_ps(ret, _mm256_div_ps(_mm256_set1_ps(1 / 12.f), x_3));
+	ret = _mm256_sub_ps(ret, log_ps(_mm256_mul_ps(
+		_mm256_mul_ps(_mm256_sub_ps(x_3, _mm256_set1_ps(1)), _mm256_sub_ps(x_3, _mm256_set1_ps(2))), x)));
+	return ret;
+}
+
+// approximation : lgamma(z + a) - lgamma(z) = (z + a + 1.5) * log(z + a + 2) - (z + 1.5) * log(z + 2) - a + (1. / (z + a + 2) - 1. / (z + 2)) / 12. - log(((z + a) * (z + a + 1)) / (z * (z + 1)))
+inline __m256 lgamma_subt(__m256 z, __m256 a)
+{
+	__m256 _1p5 = _mm256_set1_ps(1.5);
+	__m256 _2 = _mm256_set1_ps(2);
+	__m256 za = _mm256_add_ps(z, a);
+	__m256 ret = _mm256_mul_ps(_mm256_add_ps(za, _1p5), log_ps(_mm256_add_ps(za, _2)));
+	ret = _mm256_sub_ps(ret, _mm256_mul_ps(_mm256_add_ps(z, _1p5), log_ps(_mm256_add_ps(z, _2))));
+	ret = _mm256_sub_ps(ret, a);
+	__m256 _1 = _mm256_set1_ps(1);
+	__m256 _1_12 = _mm256_set1_ps(1 / 12.f);
+	ret = _mm256_add_ps(ret, _mm256_sub_ps(_mm256_div_ps(_1_12, _mm256_add_ps(za, _2)), _mm256_div_ps(_1_12, _mm256_add_ps(z, _2))));
+	ret = _mm256_sub_ps(ret, log_ps(_mm256_div_ps(_mm256_div_ps(_mm256_mul_ps(za, _mm256_add_ps(za, _1)), z), _mm256_add_ps(z, _1))));
+	return ret;
+}
+
+
+// approximation : digamma(z) ~= ln(z+4) - 1/2/(z+4) - 1/12/(z+4)^2 - 1/z - 1/(z+1) - 1/(z+2) - 1/(z+3)
+inline __m256 digamma_ps(__m256 x)
+{
+	__m256 x_4 = _mm256_add_ps(x, _mm256_set1_ps(4));
+	__m256 ret = log_ps(x_4);
+	ret = _mm256_sub_ps(ret, _mm256_div_ps(_mm256_set1_ps(1 / 2.f), x_4));
+	ret = _mm256_sub_ps(ret, _mm256_div_ps(_mm256_div_ps(_mm256_set1_ps(1 / 12.f), x_4), x_4));
+	ret = _mm256_sub_ps(ret, _mm256_rcp_ps(_mm256_sub_ps(x_4, _mm256_set1_ps(1))));
+	ret = _mm256_sub_ps(ret, _mm256_rcp_ps(_mm256_sub_ps(x_4, _mm256_set1_ps(2))));
+	ret = _mm256_sub_ps(ret, _mm256_rcp_ps(_mm256_sub_ps(x_4, _mm256_set1_ps(3))));
+	ret = _mm256_sub_ps(ret, _mm256_rcp_ps(_mm256_sub_ps(x_4, _mm256_set1_ps(4))));
+	return ret;
+}

data/vendor/tomotopy/src/Utils/avx_mathfun.h

@@ -0,0 +1,736 @@
+/*
+AVX implementation of sin, cos, sincos, exp and log
+
+Based on "sse_mathfun.h", by Julien Pommier
+http://gruntthepeon.free.fr/ssemath/
+
+Copyright (C) 2012 Giovanni Garberoglio
+Interdisciplinary Laboratory for Computational Science (LISC)
+Fondazione Bruno Kessler and University of Trento
+via Sommarive, 18
+I-38123 Trento (Italy)
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+(this is the zlib license)
+*/
+
+#include <immintrin.h>
+
+/* yes I know, the top of this file is quite ugly */
+#ifdef _MSC_VER
+#define ALIGN32_BEG __declspec(align(32))
+#define ALIGN32_END
+#define __attribute__(x)
+#else
+#define ALIGN32_BEG
+#define ALIGN32_END __attribute__((aligned(32)))
+#endif
+
+/* __m128 is ugly to write */
+typedef __m256  v8sf; // std::vector of 8 float (avx)
+typedef __m256i v8si; // std::vector of 8 int   (avx)
+typedef __m128i v4si; // std::vector of 8 int   (avx)
+
+#define _PI32AVX_CONST(Name, Val)                                            \
+  static const ALIGN32_BEG int _pi32avx_##Name[4] ALIGN32_END = { Val, Val, Val, Val }
+
+_PI32AVX_CONST(1, 1);
+_PI32AVX_CONST(inv1, ~1);
+_PI32AVX_CONST(2, 2);
+_PI32AVX_CONST(4, 4);
+
+
+/* declare some AVX constants -- why can't I figure a better way to do that? */
+#define _PS256_CONST(Name, Val)                                            \
+  static const ALIGN32_BEG float _ps256_##Name[8] ALIGN32_END = { Val, Val, Val, Val, Val, Val, Val, Val }
+#define _PI32_CONST256(Name, Val)                                            \
+  static const ALIGN32_BEG int _pi32_256_##Name[8] ALIGN32_END = { Val, Val, Val, Val, Val, Val, Val, Val }
+#define _PS256_CONST_TYPE(Name, Type, Val)                                 \
+  static const ALIGN32_BEG Type _ps256_##Name[8] ALIGN32_END = { Val, Val, Val, Val, Val, Val, Val, Val }
+
+_PS256_CONST(1, 1.0f);
+_PS256_CONST(0p5, 0.5f);
+/* the smallest non denormalized float number */
+_PS256_CONST_TYPE(min_norm_pos, unsigned int, 0x00800000u);
+_PS256_CONST_TYPE(mant_mask, unsigned int, 0x7f800000u);
+_PS256_CONST_TYPE(inv_mant_mask, unsigned int, ~0x7f800000u);
+
+_PS256_CONST_TYPE(sign_mask, unsigned int, 0x80000000u);
+_PS256_CONST_TYPE(inv_sign_mask, unsigned int, ~0x80000000u);
+
+_PI32_CONST256(0, 0);
+_PI32_CONST256(1, 1);
+_PI32_CONST256(inv1, ~1);
+_PI32_CONST256(2, 2);
+_PI32_CONST256(4, 4);
+_PI32_CONST256(0x7f, 0x7f);
+
+_PS256_CONST(cephes_SQRTHF, 0.707106781186547524f);
+_PS256_CONST(cephes_log_p0, 7.0376836292E-2f);
+_PS256_CONST(cephes_log_p1, -1.1514610310E-1f);
+_PS256_CONST(cephes_log_p2, 1.1676998740E-1f);
+_PS256_CONST(cephes_log_p3, -1.2420140846E-1f);
+_PS256_CONST(cephes_log_p4, +1.4249322787E-1f);
+_PS256_CONST(cephes_log_p5, -1.6668057665E-1f);
+_PS256_CONST(cephes_log_p6, +2.0000714765E-1f);
+_PS256_CONST(cephes_log_p7, -2.4999993993E-1f);
+_PS256_CONST(cephes_log_p8, +3.3333331174E-1f);
+_PS256_CONST(cephes_log_q1, -2.12194440e-4f);
+_PS256_CONST(cephes_log_q2, 0.693359375f);
+
+#ifndef __AVX2__
+
+typedef union imm_xmm_union {
+	v8si imm;
+	v4si xmm[2];
+} imm_xmm_union;
+
+#define COPY_IMM_TO_XMM(imm_, xmm0_, xmm1_) {    \
+    imm_xmm_union u __attribute__((aligned(32)));  \
+    u.imm = imm_;				   \
+    xmm0_ = u.xmm[0];                            \
+    xmm1_ = u.xmm[1];                            \
+}
+
+#define COPY_XMM_TO_IMM(xmm0_, xmm1_, imm_) {                       \
+    imm_xmm_union u __attribute__((aligned(32))); \
+    u.xmm[0]=xmm0_; u.xmm[1]=xmm1_; imm_ = u.imm; \
+  }
+
+#define AVX2_BITOP_USING_SSE2(fn) \
+static inline v8si p_mm256_##fn(v8si x, int a) \
+{ \
+  /* use SSE2 instruction to perform the bitop AVX2 */ \
+  v4si x1, x2; \
+  v8si ret; \
+  COPY_IMM_TO_XMM(x, x1, x2); \
+  x1 = _mm_##fn(x1,a); \
+  x2 = _mm_##fn(x2,a); \
+  COPY_XMM_TO_IMM(x1, x2, ret); \
+  return(ret); \
+}
+
+#define AVX2_INTOP_USING_SSE2(fn) \
+static inline v8si p_mm256_##fn(v8si x, v8si y) \
+{ \
+  /* use SSE2 instructions to perform the AVX2 integer operation */ \
+  v4si x1, x2; \
+  v4si y1, y2; \
+  v8si ret; \
+  COPY_IMM_TO_XMM(x, x1, x2); \
+  COPY_IMM_TO_XMM(y, y1, y2); \
+  x1 = _mm_##fn(x1,y1); \
+  x2 = _mm_##fn(x2,y2); \
+  COPY_XMM_TO_IMM(x1, x2, ret); \
+  return(ret); \
+}
+
+#define AVX2_INTOP_USING_SSE2_128(fn) \
+static inline v8si p_mm256_##fn##256(v8si x, v8si y) \
+{ \
+  /* use SSE2 instructions to perform the AVX2 integer operation */ \
+  v4si x1, x2; \
+  v4si y1, y2; \
+  v8si ret; \
+  COPY_IMM_TO_XMM(x, x1, x2); \
+  COPY_IMM_TO_XMM(y, y1, y2); \
+  x1 = _mm_##fn##128(x1,y1); \
+  x2 = _mm_##fn##128(x2,y2); \
+  COPY_XMM_TO_IMM(x1, x2, ret); \
+  return(ret); \
+}
+#else
+
+#define AVX2_BITOP_USING_SSE2(fn) \
+static inline v8si p_mm256_##fn(v8si x, int a) { return _mm256_##fn(x, a); }
+
+#define AVX2_INTOP_USING_SSE2(fn) \
+static inline v8si p_mm256_##fn(v8si x, v8si y) { return _mm256_##fn(x, y); }
+
+#define AVX2_INTOP_USING_SSE2_128(fn) \
+static inline v8si p_mm256_##fn##256(v8si x, v8si y) { return _mm256_##fn##256(x, y); }
+
+#endif /* __AVX2__ */
+
+AVX2_BITOP_USING_SSE2(slli_epi32)
+AVX2_BITOP_USING_SSE2(srli_epi32)
+
+AVX2_INTOP_USING_SSE2(cmpeq_epi32)
+AVX2_INTOP_USING_SSE2(sub_epi32)
+AVX2_INTOP_USING_SSE2(add_epi32)
+
+/* natural logarithm computed for 8 simultaneous float
+return NaN for x <= 0
+*/
+inline v8sf log_ps(v8sf x) {
+	v8si imm0;
+	v8sf one = *(v8sf*)_ps256_1;
+
+	//v8sf invalid_mask = _mm256_cmple_ps(x, _mm256_setzero_ps());
+	v8sf invalid_mask = _mm256_cmp_ps(x, _mm256_setzero_ps(), _CMP_LE_OS);
+
+	x = _mm256_max_ps(x, *(v8sf*)_ps256_min_norm_pos);  /* cut off denormalized stuff */
+
+														// can be done with AVX2
+	imm0 = p_mm256_srli_epi32(_mm256_castps_si256(x), 23);
+
+	/* keep only the fractional part */
+	x = _mm256_and_ps(x, *(v8sf*)_ps256_inv_mant_mask);
+	x = _mm256_or_ps(x, *(v8sf*)_ps256_0p5);
+
+	// this is again another AVX2 instruction
+	imm0 = p_mm256_sub_epi32(imm0, *(v8si*)_pi32_256_0x7f);
+	v8sf e = _mm256_cvtepi32_ps(imm0);
+
+	e = _mm256_add_ps(e, one);
+
+	/* part2:
+	if( x < SQRTHF ) {
+	e -= 1;
+	x = x + x - 1.0;
+	} else { x = x - 1.0; }
+	*/
+	//v8sf mask = _mm256_cmplt_ps(x, *(v8sf*)_ps256_cephes_SQRTHF);
+	v8sf mask = _mm256_cmp_ps(x, *(v8sf*)_ps256_cephes_SQRTHF, _CMP_LT_OS);
+	v8sf tmp = _mm256_and_ps(x, mask);
+	x = _mm256_sub_ps(x, one);
+	e = _mm256_sub_ps(e, _mm256_and_ps(one, mask));
+	x = _mm256_add_ps(x, tmp);
+
+	v8sf z = _mm256_mul_ps(x, x);
+
+	v8sf y = *(v8sf*)_ps256_cephes_log_p0;
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_log_p1);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_log_p2);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_log_p3);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_log_p4);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_log_p5);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_log_p6);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_log_p7);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_log_p8);
+	y = _mm256_mul_ps(y, x);
+
+	y = _mm256_mul_ps(y, z);
+
+	tmp = _mm256_mul_ps(e, *(v8sf*)_ps256_cephes_log_q1);
+	y = _mm256_add_ps(y, tmp);
+
+
+	tmp = _mm256_mul_ps(z, *(v8sf*)_ps256_0p5);
+	y = _mm256_sub_ps(y, tmp);
+
+	tmp = _mm256_mul_ps(e, *(v8sf*)_ps256_cephes_log_q2);
+	x = _mm256_add_ps(x, y);
+	x = _mm256_add_ps(x, tmp);
+	x = _mm256_or_ps(x, invalid_mask); // negative arg will be NAN
+	return x;
+}
+
+_PS256_CONST(exp_hi, 88.3762626647949f);
+_PS256_CONST(exp_lo, -88.3762626647949f);
+
+_PS256_CONST(cephes_LOG2EF, 1.44269504088896341f);
+_PS256_CONST(cephes_exp_C1, 0.693359375f);
+_PS256_CONST(cephes_exp_C2, -2.12194440e-4f);
+
+_PS256_CONST(cephes_exp_p0, 1.9875691500E-4f);
+_PS256_CONST(cephes_exp_p1, 1.3981999507E-3f);
+_PS256_CONST(cephes_exp_p2, 8.3334519073E-3f);
+_PS256_CONST(cephes_exp_p3, 4.1665795894E-2f);
+_PS256_CONST(cephes_exp_p4, 1.6666665459E-1f);
+_PS256_CONST(cephes_exp_p5, 5.0000001201E-1f);
+
+inline v8sf exp_ps(v8sf x) {
+	v8sf tmp = _mm256_setzero_ps(), fx;
+	v8si imm0;
+	v8sf one = *(v8sf*)_ps256_1;
+
+	x = _mm256_min_ps(x, *(v8sf*)_ps256_exp_hi);
+	x = _mm256_max_ps(x, *(v8sf*)_ps256_exp_lo);
+
+	/* express exp(x) as exp(g + n*log(2)) */
+	fx = _mm256_mul_ps(x, *(v8sf*)_ps256_cephes_LOG2EF);
+	fx = _mm256_add_ps(fx, *(v8sf*)_ps256_0p5);
+
+	/* how to perform a floorf with SSE: just below */
+	//imm0 = _mm256_cvttps_epi32(fx);
+	//tmp  = _mm256_cvtepi32_ps(imm0);
+
+	tmp = _mm256_floor_ps(fx);
+
+	/* if greater, substract 1 */
+	//v8sf mask = _mm256_cmpgt_ps(tmp, fx);    
+	v8sf mask = _mm256_cmp_ps(tmp, fx, _CMP_GT_OS);
+	mask = _mm256_and_ps(mask, one);
+	fx = _mm256_sub_ps(tmp, mask);
+
+	tmp = _mm256_mul_ps(fx, *(v8sf*)_ps256_cephes_exp_C1);
+	v8sf z = _mm256_mul_ps(fx, *(v8sf*)_ps256_cephes_exp_C2);
+	x = _mm256_sub_ps(x, tmp);
+	x = _mm256_sub_ps(x, z);
+
+	z = _mm256_mul_ps(x, x);
+
+	v8sf y = *(v8sf*)_ps256_cephes_exp_p0;
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_exp_p1);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_exp_p2);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_exp_p3);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_exp_p4);
+	y = _mm256_mul_ps(y, x);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_cephes_exp_p5);
+	y = _mm256_mul_ps(y, z);
+	y = _mm256_add_ps(y, x);
+	y = _mm256_add_ps(y, one);
+
+	/* build 2^n */
+	imm0 = _mm256_cvttps_epi32(fx);
+	// another two AVX2 instructions
+	imm0 = p_mm256_add_epi32(imm0, *(v8si*)_pi32_256_0x7f);
+	imm0 = p_mm256_slli_epi32(imm0, 23);
+	v8sf pow2n = _mm256_castsi256_ps(imm0);
+	y = _mm256_mul_ps(y, pow2n);
+	return y;
+}
+
+_PS256_CONST(minus_cephes_DP1, -0.78515625f);
+_PS256_CONST(minus_cephes_DP2, -2.4187564849853515625e-4f);
+_PS256_CONST(minus_cephes_DP3, -3.77489497744594108e-8f);
+_PS256_CONST(sincof_p0, -1.9515295891E-4f);
+_PS256_CONST(sincof_p1, 8.3321608736E-3f);
+_PS256_CONST(sincof_p2, -1.6666654611E-1f);
+_PS256_CONST(coscof_p0, 2.443315711809948E-005f);
+_PS256_CONST(coscof_p1, -1.388731625493765E-003f);
+_PS256_CONST(coscof_p2, 4.166664568298827E-002f);
+_PS256_CONST(cephes_FOPI, 1.27323954473516f); // 4 / M_PI
+
+
+											 /* evaluation of 8 sines at onces using AVX intrisics
+
+											 The code is the exact rewriting of the cephes sinf function.
+											 Precision is excellent as long as x < 8192 (I did not bother to
+											 take into account the special handling they have for greater values
+											 -- it does not return garbage for arguments over 8192, though, but
+											 the extra precision is missing).
+
+											 Note that it is such that sinf((float)M_PI) = 8.74e-8, which is the
+											 surprising but correct result.
+
+											 */
+inline v8sf sin_ps(v8sf x) { // any x
+	v8sf xmm1, xmm2 = _mm256_setzero_ps(), xmm3, sign_bit, y;
+	v8si imm0, imm2;
+
+#ifndef __AVX2__
+	v4si imm0_1, imm0_2;
+	v4si imm2_1, imm2_2;
+#endif
+
+	sign_bit = x;
+	/* take the absolute value */
+	x = _mm256_and_ps(x, *(v8sf*)_ps256_inv_sign_mask);
+	/* extract the sign bit (upper one) */
+	sign_bit = _mm256_and_ps(sign_bit, *(v8sf*)_ps256_sign_mask);
+
+	/* scale by 4/Pi */
+	y = _mm256_mul_ps(x, *(v8sf*)_ps256_cephes_FOPI);
+
+	/*
+	Here we start a series of integer operations, which are in the
+	realm of AVX2.
+	If we don't have AVX, let's perform them using SSE2 directives
+	*/
+
+#ifdef __AVX2__
+	/* store the integer part of y in mm0 */
+	imm2 = _mm256_cvttps_epi32(y);
+	/* j=(j+1) & (~1) (see the cephes sources) */
+	// another two AVX2 instruction
+	imm2 = p_mm256_add_epi32(imm2, *(v8si*)_pi32_256_1);
+	imm2 = _mm256_and_si256(imm2, *(v8si*)_pi32_256_inv1);
+	y = _mm256_cvtepi32_ps(imm2);
+
+	/* get the swap sign flag */
+	imm0 = _mm256_and_si256(imm2, *(v8si*)_pi32_256_4);
+	imm0 = p_mm256_slli_epi32(imm0, 29);
+	/* get the polynom selection mask
+	there is one polynom for 0 <= x <= Pi/4
+	and another one for Pi/4<x<=Pi/2
+
+	Both branches will be computed.
+	*/
+	imm2 = _mm256_and_si256(imm2, *(v8si*)_pi32_256_2);
+	imm2 = p_mm256_cmpeq_epi32(imm2, *(v8si*)_pi32_256_0);
+#else
+	/* we use SSE2 routines to perform the integer ops */
+	COPY_IMM_TO_XMM(_mm256_cvttps_epi32(y), imm2_1, imm2_2);
+
+	imm2_1 = _mm_add_epi32(imm2_1, *(v4si*)_pi32avx_1);
+	imm2_2 = _mm_add_epi32(imm2_2, *(v4si*)_pi32avx_1);
+
+	imm2_1 = _mm_and_si128(imm2_1, *(v4si*)_pi32avx_inv1);
+	imm2_2 = _mm_and_si128(imm2_2, *(v4si*)_pi32avx_inv1);
+
+	COPY_XMM_TO_IMM(imm2_1, imm2_2, imm2);
+	y = _mm256_cvtepi32_ps(imm2);
+
+	imm0_1 = _mm_and_si128(imm2_1, *(v4si*)_pi32avx_4);
+	imm0_2 = _mm_and_si128(imm2_2, *(v4si*)_pi32avx_4);
+
+	imm0_1 = _mm_slli_epi32(imm0_1, 29);
+	imm0_2 = _mm_slli_epi32(imm0_2, 29);
+
+	COPY_XMM_TO_IMM(imm0_1, imm0_2, imm0);
+
+	imm2_1 = _mm_and_si128(imm2_1, *(v4si*)_pi32avx_2);
+	imm2_2 = _mm_and_si128(imm2_2, *(v4si*)_pi32avx_2);
+
+	imm2_1 = _mm_cmpeq_epi32(imm2_1, _mm_setzero_si128());
+	imm2_2 = _mm_cmpeq_epi32(imm2_2, _mm_setzero_si128());
+
+	COPY_XMM_TO_IMM(imm2_1, imm2_2, imm2);
+#endif
+
+	v8sf swap_sign_bit = _mm256_castsi256_ps(imm0);
+	v8sf poly_mask = _mm256_castsi256_ps(imm2);
+	sign_bit = _mm256_xor_ps(sign_bit, swap_sign_bit);
+
+	/* The magic pass: "Extended precision modular arithmetic"
+	x = ((x - y * DP1) - y * DP2) - y * DP3; */
+	xmm1 = *(v8sf*)_ps256_minus_cephes_DP1;
+	xmm2 = *(v8sf*)_ps256_minus_cephes_DP2;
+	xmm3 = *(v8sf*)_ps256_minus_cephes_DP3;
+	xmm1 = _mm256_mul_ps(y, xmm1);
+	xmm2 = _mm256_mul_ps(y, xmm2);
+	xmm3 = _mm256_mul_ps(y, xmm3);
+	x = _mm256_add_ps(x, xmm1);
+	x = _mm256_add_ps(x, xmm2);
+	x = _mm256_add_ps(x, xmm3);
+
+	/* Evaluate the first polynom  (0 <= x <= Pi/4) */
+	y = *(v8sf*)_ps256_coscof_p0;
+	v8sf z = _mm256_mul_ps(x, x);
+
+	y = _mm256_mul_ps(y, z);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_coscof_p1);
+	y = _mm256_mul_ps(y, z);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_coscof_p2);
+	y = _mm256_mul_ps(y, z);
+	y = _mm256_mul_ps(y, z);
+	v8sf tmp = _mm256_mul_ps(z, *(v8sf*)_ps256_0p5);
+	y = _mm256_sub_ps(y, tmp);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_1);
+
+	/* Evaluate the second polynom  (Pi/4 <= x <= 0) */
+
+	v8sf y2 = *(v8sf*)_ps256_sincof_p0;
+	y2 = _mm256_mul_ps(y2, z);
+	y2 = _mm256_add_ps(y2, *(v8sf*)_ps256_sincof_p1);
+	y2 = _mm256_mul_ps(y2, z);
+	y2 = _mm256_add_ps(y2, *(v8sf*)_ps256_sincof_p2);
+	y2 = _mm256_mul_ps(y2, z);
+	y2 = _mm256_mul_ps(y2, x);
+	y2 = _mm256_add_ps(y2, x);
+
+	/* select the correct result from the two polynoms */
+	xmm3 = poly_mask;
+	y2 = _mm256_and_ps(xmm3, y2); //, xmm3);
+	y = _mm256_andnot_ps(xmm3, y);
+	y = _mm256_add_ps(y, y2);
+	/* update the sign */
+	y = _mm256_xor_ps(y, sign_bit);
+
+	return y;
+}
+
+/* almost the same as sin_ps */
+inline v8sf cos_ps(v8sf x) { // any x
+	v8sf xmm1, xmm2 = _mm256_setzero_ps(), xmm3, y;
+	v8si imm0, imm2;
+
+#ifndef __AVX2__
+	v4si imm0_1, imm0_2;
+	v4si imm2_1, imm2_2;
+#endif
+
+	/* take the absolute value */
+	x = _mm256_and_ps(x, *(v8sf*)_ps256_inv_sign_mask);
+
+	/* scale by 4/Pi */
+	y = _mm256_mul_ps(x, *(v8sf*)_ps256_cephes_FOPI);
+
+#ifdef __AVX2__
+	/* store the integer part of y in mm0 */
+	imm2 = _mm256_cvttps_epi32(y);
+	/* j=(j+1) & (~1) (see the cephes sources) */
+	imm2 = p_mm256_add_epi32(imm2, *(v8si*)_pi32_256_1);
+	imm2 = _mm256_and_si256(imm2, *(v8si*)_pi32_256_inv1);
+	y = _mm256_cvtepi32_ps(imm2);
+	imm2 = p_mm256_sub_epi32(imm2, *(v8si*)_pi32_256_2);
+
+	/* get the swap sign flag */
+	imm0 = _mm256_andnot_si256(imm2, *(v8si*)_pi32_256_4);
+	imm0 = p_mm256_slli_epi32(imm0, 29);
+	/* get the polynom selection mask */
+	imm2 = _mm256_and_si256(imm2, *(v8si*)_pi32_256_2);
+	imm2 = p_mm256_cmpeq_epi32(imm2, *(v8si*)_pi32_256_0);
+#else
+
+	/* we use SSE2 routines to perform the integer ops */
+	COPY_IMM_TO_XMM(_mm256_cvttps_epi32(y), imm2_1, imm2_2);
+
+	imm2_1 = _mm_add_epi32(imm2_1, *(v4si*)_pi32avx_1);
+	imm2_2 = _mm_add_epi32(imm2_2, *(v4si*)_pi32avx_1);
+
+	imm2_1 = _mm_and_si128(imm2_1, *(v4si*)_pi32avx_inv1);
+	imm2_2 = _mm_and_si128(imm2_2, *(v4si*)_pi32avx_inv1);
+
+	COPY_XMM_TO_IMM(imm2_1, imm2_2, imm2);
+	y = _mm256_cvtepi32_ps(imm2);
+
+	imm2_1 = _mm_sub_epi32(imm2_1, *(v4si*)_pi32avx_2);
+	imm2_2 = _mm_sub_epi32(imm2_2, *(v4si*)_pi32avx_2);
+
+	imm0_1 = _mm_andnot_si128(imm2_1, *(v4si*)_pi32avx_4);
+	imm0_2 = _mm_andnot_si128(imm2_2, *(v4si*)_pi32avx_4);
+
+	imm0_1 = _mm_slli_epi32(imm0_1, 29);
+	imm0_2 = _mm_slli_epi32(imm0_2, 29);
+
+	COPY_XMM_TO_IMM(imm0_1, imm0_2, imm0);
+
+	imm2_1 = _mm_and_si128(imm2_1, *(v4si*)_pi32avx_2);
+	imm2_2 = _mm_and_si128(imm2_2, *(v4si*)_pi32avx_2);
+
+	imm2_1 = _mm_cmpeq_epi32(imm2_1, _mm_setzero_si128());
+	imm2_2 = _mm_cmpeq_epi32(imm2_2, _mm_setzero_si128());
+
+	COPY_XMM_TO_IMM(imm2_1, imm2_2, imm2);
+#endif
+
+	v8sf sign_bit = _mm256_castsi256_ps(imm0);
+	v8sf poly_mask = _mm256_castsi256_ps(imm2);
+
+	/* The magic pass: "Extended precision modular arithmetic"
+	x = ((x - y * DP1) - y * DP2) - y * DP3; */
+	xmm1 = *(v8sf*)_ps256_minus_cephes_DP1;
+	xmm2 = *(v8sf*)_ps256_minus_cephes_DP2;
+	xmm3 = *(v8sf*)_ps256_minus_cephes_DP3;
+	xmm1 = _mm256_mul_ps(y, xmm1);
+	xmm2 = _mm256_mul_ps(y, xmm2);
+	xmm3 = _mm256_mul_ps(y, xmm3);
+	x = _mm256_add_ps(x, xmm1);
+	x = _mm256_add_ps(x, xmm2);
+	x = _mm256_add_ps(x, xmm3);
+
+	/* Evaluate the first polynom  (0 <= x <= Pi/4) */
+	y = *(v8sf*)_ps256_coscof_p0;
+	v8sf z = _mm256_mul_ps(x, x);
+
+	y = _mm256_mul_ps(y, z);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_coscof_p1);
+	y = _mm256_mul_ps(y, z);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_coscof_p2);
+	y = _mm256_mul_ps(y, z);
+	y = _mm256_mul_ps(y, z);
+	v8sf tmp = _mm256_mul_ps(z, *(v8sf*)_ps256_0p5);
+	y = _mm256_sub_ps(y, tmp);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_1);
+
+	/* Evaluate the second polynom  (Pi/4 <= x <= 0) */
+
+	v8sf y2 = *(v8sf*)_ps256_sincof_p0;
+	y2 = _mm256_mul_ps(y2, z);
+	y2 = _mm256_add_ps(y2, *(v8sf*)_ps256_sincof_p1);
+	y2 = _mm256_mul_ps(y2, z);
+	y2 = _mm256_add_ps(y2, *(v8sf*)_ps256_sincof_p2);
+	y2 = _mm256_mul_ps(y2, z);
+	y2 = _mm256_mul_ps(y2, x);
+	y2 = _mm256_add_ps(y2, x);
+
+	/* select the correct result from the two polynoms */
+	xmm3 = poly_mask;
+	y2 = _mm256_and_ps(xmm3, y2); //, xmm3);
+	y = _mm256_andnot_ps(xmm3, y);
+	y = _mm256_add_ps(y, y2);
+	/* update the sign */
+	y = _mm256_xor_ps(y, sign_bit);
+
+	return y;
+}
+
+/* since sin256_ps and cos256_ps are almost identical, sincos256_ps could replace both of them..
+it is almost as fast, and gives you a free cosine with your sine */
+inline void sincos_ps(v8sf x, v8sf *s, v8sf *c) {
+
+	v8sf xmm1, xmm2, xmm3 = _mm256_setzero_ps(), sign_bit_sin, y;
+	v8si imm0, imm2, imm4;
+
+#ifndef __AVX2__
+	v4si imm0_1, imm0_2;
+	v4si imm2_1, imm2_2;
+	v4si imm4_1, imm4_2;
+#endif
+
+	sign_bit_sin = x;
+	/* take the absolute value */
+	x = _mm256_and_ps(x, *(v8sf*)_ps256_inv_sign_mask);
+	/* extract the sign bit (upper one) */
+	sign_bit_sin = _mm256_and_ps(sign_bit_sin, *(v8sf*)_ps256_sign_mask);
+
+	/* scale by 4/Pi */
+	y = _mm256_mul_ps(x, *(v8sf*)_ps256_cephes_FOPI);
+
+#ifdef __AVX2__    
+	/* store the integer part of y in imm2 */
+	imm2 = _mm256_cvttps_epi32(y);
+
+	/* j=(j+1) & (~1) (see the cephes sources) */
+	imm2 = p_mm256_add_epi32(imm2, *(v8si*)_pi32_256_1);
+	imm2 = _mm256_and_si256(imm2, *(v8si*)_pi32_256_inv1);
+
+	y = _mm256_cvtepi32_ps(imm2);
+	imm4 = imm2;
+
+	/* get the swap sign flag for the sine */
+	imm0 = _mm256_and_si256(imm2, *(v8si*)_pi32_256_4);
+	imm0 = p_mm256_slli_epi32(imm0, 29);
+	//v8sf swap_sign_bit_sin = _mm256_castsi256_ps(imm0);
+
+	/* get the polynom selection mask for the sine*/
+	imm2 = _mm256_and_si256(imm2, *(v8si*)_pi32_256_2);
+	imm2 = p_mm256_cmpeq_epi32(imm2, *(v8si*)_pi32_256_0);
+	//v8sf poly_mask = _mm256_castsi256_ps(imm2);
+#else
+	/* we use SSE2 routines to perform the integer ops */
+	COPY_IMM_TO_XMM(_mm256_cvttps_epi32(y), imm2_1, imm2_2);
+
+	imm2_1 = _mm_add_epi32(imm2_1, *(v4si*)_pi32avx_1);
+	imm2_2 = _mm_add_epi32(imm2_2, *(v4si*)_pi32avx_1);
+
+	imm2_1 = _mm_and_si128(imm2_1, *(v4si*)_pi32avx_inv1);
+	imm2_2 = _mm_and_si128(imm2_2, *(v4si*)_pi32avx_inv1);
+
+	COPY_XMM_TO_IMM(imm2_1, imm2_2, imm2);
+	y = _mm256_cvtepi32_ps(imm2);
+
+	imm4_1 = imm2_1;
+	imm4_2 = imm2_2;
+
+	imm0_1 = _mm_and_si128(imm2_1, *(v4si*)_pi32avx_4);
+	imm0_2 = _mm_and_si128(imm2_2, *(v4si*)_pi32avx_4);
+
+	imm0_1 = _mm_slli_epi32(imm0_1, 29);
+	imm0_2 = _mm_slli_epi32(imm0_2, 29);
+
+	COPY_XMM_TO_IMM(imm0_1, imm0_2, imm0);
+
+	imm2_1 = _mm_and_si128(imm2_1, *(v4si*)_pi32avx_2);
+	imm2_2 = _mm_and_si128(imm2_2, *(v4si*)_pi32avx_2);
+
+	imm2_1 = _mm_cmpeq_epi32(imm2_1, _mm_setzero_si128());
+	imm2_2 = _mm_cmpeq_epi32(imm2_2, _mm_setzero_si128());
+
+	COPY_XMM_TO_IMM(imm2_1, imm2_2, imm2);
+#endif
+	v8sf swap_sign_bit_sin = _mm256_castsi256_ps(imm0);
+	v8sf poly_mask = _mm256_castsi256_ps(imm2);
+
+	/* The magic pass: "Extended precision modular arithmetic"
+	x = ((x - y * DP1) - y * DP2) - y * DP3; */
+	xmm1 = *(v8sf*)_ps256_minus_cephes_DP1;
+	xmm2 = *(v8sf*)_ps256_minus_cephes_DP2;
+	xmm3 = *(v8sf*)_ps256_minus_cephes_DP3;
+	xmm1 = _mm256_mul_ps(y, xmm1);
+	xmm2 = _mm256_mul_ps(y, xmm2);
+	xmm3 = _mm256_mul_ps(y, xmm3);
+	x = _mm256_add_ps(x, xmm1);
+	x = _mm256_add_ps(x, xmm2);
+	x = _mm256_add_ps(x, xmm3);
+
+#ifdef __AVX2__
+	imm4 = p_mm256_sub_epi32(imm4, *(v8si*)_pi32_256_2);
+	imm4 = _mm256_andnot_si256(imm4, *(v8si*)_pi32_256_4);
+	imm4 = p_mm256_slli_epi32(imm4, 29);
+#else
+	imm4_1 = _mm_sub_epi32(imm4_1, *(v4si*)_pi32avx_2);
+	imm4_2 = _mm_sub_epi32(imm4_2, *(v4si*)_pi32avx_2);
+
+	imm4_1 = _mm_andnot_si128(imm4_1, *(v4si*)_pi32avx_4);
+	imm4_2 = _mm_andnot_si128(imm4_2, *(v4si*)_pi32avx_4);
+
+	imm4_1 = _mm_slli_epi32(imm4_1, 29);
+	imm4_2 = _mm_slli_epi32(imm4_2, 29);
+
+	COPY_XMM_TO_IMM(imm4_1, imm4_2, imm4);
+#endif
+
+	v8sf sign_bit_cos = _mm256_castsi256_ps(imm4);
+
+	sign_bit_sin = _mm256_xor_ps(sign_bit_sin, swap_sign_bit_sin);
+
+	/* Evaluate the first polynom  (0 <= x <= Pi/4) */
+	v8sf z = _mm256_mul_ps(x, x);
+	y = *(v8sf*)_ps256_coscof_p0;
+
+	y = _mm256_mul_ps(y, z);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_coscof_p1);
+	y = _mm256_mul_ps(y, z);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_coscof_p2);
+	y = _mm256_mul_ps(y, z);
+	y = _mm256_mul_ps(y, z);
+	v8sf tmp = _mm256_mul_ps(z, *(v8sf*)_ps256_0p5);
+	y = _mm256_sub_ps(y, tmp);
+	y = _mm256_add_ps(y, *(v8sf*)_ps256_1);
+
+	/* Evaluate the second polynom  (Pi/4 <= x <= 0) */
+
+	v8sf y2 = *(v8sf*)_ps256_sincof_p0;
+	y2 = _mm256_mul_ps(y2, z);
+	y2 = _mm256_add_ps(y2, *(v8sf*)_ps256_sincof_p1);
+	y2 = _mm256_mul_ps(y2, z);
+	y2 = _mm256_add_ps(y2, *(v8sf*)_ps256_sincof_p2);
+	y2 = _mm256_mul_ps(y2, z);
+	y2 = _mm256_mul_ps(y2, x);
+	y2 = _mm256_add_ps(y2, x);
+
+	/* select the correct result from the two polynoms */
+	xmm3 = poly_mask;
+	v8sf ysin2 = _mm256_and_ps(xmm3, y2);
+	v8sf ysin1 = _mm256_andnot_ps(xmm3, y);
+	y2 = _mm256_sub_ps(y2, ysin2);
+	y = _mm256_sub_ps(y, ysin1);
+
+	xmm1 = _mm256_add_ps(ysin1, ysin2);
+	xmm2 = _mm256_add_ps(y, y2);
+
+	/* update the sign */
+	*s = _mm256_xor_ps(xmm1, sign_bit_sin);
+	*c = _mm256_xor_ps(xmm2, sign_bit_cos);
+}