// This file is part of Eigen, a lightweight C++ template library // for linear algebra. // // Copyright (C) 2008-2009 Gael Guennebaud // Copyright (C) 2006-2008 Benoit Jacob // // Eigen is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 3 of the License, or (at your option) any later version. // // Alternatively, you can redistribute it and/or // modify it under the terms of the GNU General Public License as // published by the Free Software Foundation; either version 2 of // the License, or (at your option) any later version. // // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the // GNU General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License and a copy of the GNU General Public License along with // Eigen. If not, see . #include "main.h" // using namespace Eigen; namespace Eigen { namespace internal { template T negate(const T& x) { return -x; } } } template bool isApproxAbs(const Scalar& a, const Scalar& b, const typename NumTraits::Real& refvalue) { return internal::isMuchSmallerThan(a-b, refvalue); } template bool areApproxAbs(const Scalar* a, const Scalar* b, int size, const typename NumTraits::Real& refvalue) { for (int i=0; i bool areApprox(const Scalar* a, const Scalar* b, int size) { for (int i=0; i(data1), internal::pload(data1+PacketSize))); \ VERIFY(areApprox(ref, data2, PacketSize) && #POP); \ } #define CHECK_CWISE1(REFOP, POP) { \ for (int i=0; i(data1))); \ VERIFY(areApprox(ref, data2, PacketSize) && #POP); \ } template struct packet_helper { template inline Packet load(const T* from) const { return internal::pload(from); } template inline void store(T* to, const Packet& x) const { internal::pstore(to,x); } }; template struct packet_helper { template inline T load(const T* from) const { return *from; } template inline void store(T* to, const T& x) const { *to = x; } }; #define CHECK_CWISE1_IF(COND, REFOP, POP) if(COND) { \ packet_helper h; \ for (int i=0; i void packetmath() { typedef typename internal::packet_traits::type Packet; const int PacketSize = internal::packet_traits::size; typedef typename NumTraits::Real RealScalar; const int size = PacketSize*4; EIGEN_ALIGN16 Scalar data1[internal::packet_traits::size*4]; EIGEN_ALIGN16 Scalar data2[internal::packet_traits::size*4]; EIGEN_ALIGN16 Packet packets[PacketSize*2]; EIGEN_ALIGN16 Scalar ref[internal::packet_traits::size*4]; RealScalar refvalue = 0; for (int i=0; i(); data2[i] = internal::random(); refvalue = std::max(refvalue,internal::abs(data1[i])); } internal::pstore(data2, internal::pload(data1)); VERIFY(areApprox(data1, data2, PacketSize) && "aligned load/store"); for (int offset=0; offset(data1+offset)); VERIFY(areApprox(data1+offset, data2, PacketSize) && "internal::ploadu"); } for (int offset=0; offset(data1)); VERIFY(areApprox(data1, data2+offset, PacketSize) && "internal::pstoreu"); } for (int offset=0; offset(data1); packets[1] = internal::pload(data1+PacketSize); if (offset==0) internal::palign<0>(packets[0], packets[1]); else if (offset==1) internal::palign<1>(packets[0], packets[1]); else if (offset==2) internal::palign<2>(packets[0], packets[1]); else if (offset==3) internal::palign<3>(packets[0], packets[1]); internal::pstore(data2, packets[0]); for (int i=0; i Vector; VERIFY(areApprox(ref, data2, PacketSize) && "internal::palign"); } CHECK_CWISE2(REF_ADD, internal::padd); CHECK_CWISE2(REF_SUB, internal::psub); CHECK_CWISE2(REF_MUL, internal::pmul); #ifndef EIGEN_VECTORIZE_ALTIVEC if (!internal::is_same::value) CHECK_CWISE2(REF_DIV, internal::pdiv); #endif CHECK_CWISE1(internal::negate, internal::pnegate); CHECK_CWISE1(internal::conj, internal::pconj); for (int i=0; i(data1[0])); VERIFY(areApprox(ref, data2, PacketSize) && "internal::pset1"); VERIFY(internal::isApprox(data1[0], internal::pfirst(internal::pload(data1))) && "internal::pfirst"); ref[0] = 0; for (int i=0; i(data1)), refvalue) && "internal::predux"); ref[0] = 1; for (int i=0; i(data1))) && "internal::predux_mul"); for (int j=0; j(data1+j*PacketSize); } internal::pstore(data2, internal::preduxp(packets)); VERIFY(areApproxAbs(ref, data2, PacketSize, refvalue) && "internal::preduxp"); for (int i=0; i(data1))); VERIFY(areApprox(ref, data2, PacketSize) && "internal::preverse"); } template void packetmath_real() { typedef typename internal::packet_traits::type Packet; const int PacketSize = internal::packet_traits::size; const int size = PacketSize*4; EIGEN_ALIGN16 Scalar data1[internal::packet_traits::size*4]; EIGEN_ALIGN16 Scalar data2[internal::packet_traits::size*4]; EIGEN_ALIGN16 Scalar ref[internal::packet_traits::size*4]; for (int i=0; i(-1e3,1e3); data2[i] = internal::random(-1e3,1e3); } CHECK_CWISE1_IF(internal::packet_traits::HasSin, internal::sin, internal::psin); CHECK_CWISE1_IF(internal::packet_traits::HasCos, internal::cos, internal::pcos); for (int i=0; i(-87,88); data2[i] = internal::random(-87,88); } CHECK_CWISE1_IF(internal::packet_traits::HasExp, internal::exp, internal::pexp); for (int i=0; i(0,1e6); data2[i] = internal::random(0,1e6); } CHECK_CWISE1_IF(internal::packet_traits::HasLog, internal::log, internal::plog); CHECK_CWISE1_IF(internal::packet_traits::HasSqrt, internal::sqrt, internal::psqrt); ref[0] = data1[0]; for (int i=0; i(data1))) && "internal::predux_min"); CHECK_CWISE2(std::min, internal::pmin); CHECK_CWISE2(std::max, internal::pmax); CHECK_CWISE1(internal::abs, internal::pabs); ref[0] = data1[0]; for (int i=0; i(data1))) && "internal::predux_max"); } template void packetmath_complex() { typedef typename internal::packet_traits::type Packet; const int PacketSize = internal::packet_traits::size; const int size = PacketSize*4; EIGEN_ALIGN16 Scalar data1[PacketSize*4]; EIGEN_ALIGN16 Scalar data2[PacketSize*4]; EIGEN_ALIGN16 Scalar ref[PacketSize*4]; EIGEN_ALIGN16 Scalar pval[PacketSize*4]; for (int i=0; i() * Scalar(1e2); data2[i] = internal::random() * Scalar(1e2); } { internal::conj_helper cj; internal::conj_helper pcj; for(int i=0;i(data1),internal::pload(data2))); VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper"); } { internal::conj_helper cj; internal::conj_helper pcj; for(int i=0;i(data1),internal::pload(data2))); VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper"); } { internal::conj_helper cj; internal::conj_helper pcj; for(int i=0;i(data1),internal::pload(data2))); VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper"); } { internal::conj_helper cj; internal::conj_helper pcj; for(int i=0;i(data1),internal::pload(data2))); VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper"); } } void test_packetmath() { for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1( packetmath() ); CALL_SUBTEST_2( packetmath() ); CALL_SUBTEST_3( packetmath() ); CALL_SUBTEST_1( packetmath >() ); CALL_SUBTEST_2( packetmath >() ); CALL_SUBTEST_1( packetmath_real() ); CALL_SUBTEST_2( packetmath_real() ); CALL_SUBTEST_1( packetmath_complex >() ); CALL_SUBTEST_2( packetmath_complex >() ); } }