DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5078 Commits
11 Branches
347MB
Tree: e2302a246f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e2302a246f'
${ noResults }
JUCE/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp

1099 lines
47KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2013 - Raw Material Software Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of either:

  8.    a) the GPL v2 (or any later version)

  9.    b) the Affero GPL v3

  10. 

  11.    Details of these licenses can be found at: www.gnu.org/licenses

  12. 

  13.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  14.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  15.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  16. 

  17.    ------------------------------------------------------------------------------

  18. 

  19.    To release a closed-source product which uses JUCE, commercial licenses are

  20.    available: visit www.juce.com for more information.

  21. 

  22.   ==============================================================================

  23. */

  24. 

  25. namespace FloatVectorHelpers

  26. {

  27.     #define JUCE_INCREMENT_SRC_DEST         dest += (16 / sizeof (*dest)); src += (16 / sizeof (*dest));

  28.     #define JUCE_INCREMENT_SRC1_SRC2_DEST   dest += (16 / sizeof (*dest)); src1 += (16 / sizeof (*dest)); src2 += (16 / sizeof (*dest));

  29.     #define JUCE_INCREMENT_DEST             dest += (16 / sizeof (*dest));

  30. 

  31.    #if JUCE_USE_SSE_INTRINSICS

  32.     static bool sse2Present = false;

  33. 

  34.     static bool isSSE2Available() noexcept

  35.     {

  36.         if (sse2Present)

  37.             return true;

  38. 

  39.         sse2Present = SystemStats::hasSSE2();

  40.         return sse2Present;

  41.     }

  42. 

  43.     inline static bool isAligned (const void* p) noexcept

  44.     {

  45.         return (((pointer_sized_int) p) & 15) == 0;

  46.     }

  47. 

  48.     struct BasicOps32

  49.     {

  50.         typedef float Type;

  51.         typedef __m128 ParallelType;

  52.         enum { numParallel = 4 };

  53. 

  54.         static forcedinline ParallelType load1 (Type v) noexcept                        { return _mm_load1_ps (&v); }

  55.         static forcedinline ParallelType loadA (const Type* v) noexcept                 { return _mm_load_ps (v); }

  56.         static forcedinline ParallelType loadU (const Type* v) noexcept                 { return _mm_loadu_ps (v); }

  57.         static forcedinline void storeA (Type* dest, ParallelType a) noexcept           { _mm_store_ps (dest, a); }

  58.         static forcedinline void storeU (Type* dest, ParallelType a) noexcept           { _mm_storeu_ps (dest, a); }

  59. 

  60.         static forcedinline ParallelType add (ParallelType a, ParallelType b) noexcept  { return _mm_add_ps (a, b); }

  61.         static forcedinline ParallelType sub (ParallelType a, ParallelType b) noexcept  { return _mm_sub_ps (a, b); }

  62.         static forcedinline ParallelType mul (ParallelType a, ParallelType b) noexcept  { return _mm_mul_ps (a, b); }

  63.         static forcedinline ParallelType max (ParallelType a, ParallelType b) noexcept  { return _mm_max_ps (a, b); }

  64.         static forcedinline ParallelType min (ParallelType a, ParallelType b) noexcept  { return _mm_min_ps (a, b); }

  65. 

  66.         static forcedinline ParallelType bit_and (ParallelType a, ParallelType b) noexcept  { return _mm_and_ps (a, b); }

  67.         static forcedinline ParallelType bit_not (ParallelType a, ParallelType b) noexcept  { return _mm_andnot_ps (a, b); }

  68.         static forcedinline ParallelType bit_or  (ParallelType a, ParallelType b) noexcept  { return _mm_or_ps (a, b); }

  69.         static forcedinline ParallelType bit_xor (ParallelType a, ParallelType b) noexcept  { return _mm_xor_ps (a, b); }

  70. 

  71.         static forcedinline Type max (ParallelType a) noexcept { Type v[numParallel]; storeU (v, a); return jmax (v[0], v[1], v[2], v[3]); }

  72.         static forcedinline Type min (ParallelType a) noexcept { Type v[numParallel]; storeU (v, a); return jmin (v[0], v[1], v[2], v[3]); }

  73.     };

  74. 

  75.     struct BasicOps64

  76.     {

  77.         typedef double Type;

  78.         typedef __m128d ParallelType;

  79.         enum { numParallel = 2 };

  80. 

  81.         static forcedinline ParallelType load1 (Type v) noexcept                        { return _mm_load1_pd (&v); }

  82.         static forcedinline ParallelType loadA (const Type* v) noexcept                 { return _mm_load_pd (v); }

  83.         static forcedinline ParallelType loadU (const Type* v) noexcept                 { return _mm_loadu_pd (v); }

  84.         static forcedinline void storeA (Type* dest, ParallelType a) noexcept           { _mm_store_pd (dest, a); }

  85.         static forcedinline void storeU (Type* dest, ParallelType a) noexcept           { _mm_storeu_pd (dest, a); }

  86. 

  87.         static forcedinline ParallelType add (ParallelType a, ParallelType b) noexcept  { return _mm_add_pd (a, b); }

  88.         static forcedinline ParallelType sub (ParallelType a, ParallelType b) noexcept  { return _mm_sub_pd (a, b); }

  89.         static forcedinline ParallelType mul (ParallelType a, ParallelType b) noexcept  { return _mm_mul_pd (a, b); }

  90.         static forcedinline ParallelType max (ParallelType a, ParallelType b) noexcept  { return _mm_max_pd (a, b); }

  91.         static forcedinline ParallelType min (ParallelType a, ParallelType b) noexcept  { return _mm_min_pd (a, b); }

  92. 

  93.         static forcedinline ParallelType bit_and (ParallelType a, ParallelType b) noexcept  { return _mm_and_pd (a, b); }

  94.         static forcedinline ParallelType bit_not (ParallelType a, ParallelType b) noexcept  { return _mm_andnot_pd (a, b); }

  95.         static forcedinline ParallelType bit_or  (ParallelType a, ParallelType b) noexcept  { return _mm_or_pd (a, b); }

  96.         static forcedinline ParallelType bit_xor (ParallelType a, ParallelType b) noexcept  { return _mm_xor_pd (a, b); }

  97. 

  98.         static forcedinline Type max (ParallelType a) noexcept  { Type v[numParallel]; storeU (v, a); return jmax (v[0], v[1]); }

  99.         static forcedinline Type min (ParallelType a) noexcept  { Type v[numParallel]; storeU (v, a); return jmin (v[0], v[1]); }

  100.     };

  101. 

  102.     

  103. 

  104.     #define JUCE_BEGIN_VEC_OP \

  105.         typedef FloatVectorHelpers::ModeType<sizeof(*dest)>::Mode Mode; \

  106.         if (FloatVectorHelpers::isSSE2Available()) \

  107.         { \

  108.             const int numLongOps = num / Mode::numParallel;

  109. 

  110.     #define JUCE_FINISH_VEC_OP(normalOp) \

  111.             num &= (Mode::numParallel - 1); \

  112.             if (num == 0) return; \

  113.         } \

  114.         for (int i = 0; i < num; ++i) normalOp;

  115. 

  116.     #define JUCE_PERFORM_VEC_OP_DEST(normalOp, vecOp, locals, setupOp) \

  117.         JUCE_BEGIN_VEC_OP \

  118.         setupOp \

  119.         if (FloatVectorHelpers::isAligned (dest))   JUCE_VEC_LOOP (vecOp, dummy, Mode::loadA, Mode::storeA, locals, JUCE_INCREMENT_DEST) \

  120.         else                                        JUCE_VEC_LOOP (vecOp, dummy, Mode::loadU, Mode::storeU, locals, JUCE_INCREMENT_DEST) \

  121.         JUCE_FINISH_VEC_OP (normalOp)

  122. 

  123.     #define JUCE_PERFORM_VEC_OP_SRC_DEST(normalOp, vecOp, locals, increment, setupOp) \

  124.         JUCE_BEGIN_VEC_OP \

  125.         setupOp \

  126.         if (FloatVectorHelpers::isAligned (dest)) \

  127.         { \

  128.             if (FloatVectorHelpers::isAligned (src)) JUCE_VEC_LOOP (vecOp, Mode::loadA, Mode::loadA, Mode::storeA, locals, increment) \

  129.             else                                     JUCE_VEC_LOOP (vecOp, Mode::loadU, Mode::loadA, Mode::storeA, locals, increment) \

  130.         }\

  131.         else \

  132.         { \

  133.             if (FloatVectorHelpers::isAligned (src)) JUCE_VEC_LOOP (vecOp, Mode::loadA, Mode::loadU, Mode::storeU, locals, increment) \

  134.             else                                     JUCE_VEC_LOOP (vecOp, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  135.         } \

  136.         JUCE_FINISH_VEC_OP (normalOp)

  137. 

  138.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST(normalOp, vecOp, locals, increment, setupOp) \

  139.         JUCE_BEGIN_VEC_OP \

  140.         setupOp \

  141.         { \

  142.             Mode::ParallelType (&loadSrc1) (const Mode::Type* v) = FloatVectorHelpers::isAligned (src1) ? Mode::loadA  : Mode::loadU;          \

  143.             Mode::ParallelType (&loadSrc2) (const Mode::Type* v) = FloatVectorHelpers::isAligned (src2) ? Mode::loadA  : Mode::loadU;          \

  144.             void (&storeDst) (Mode::Type* dest, Mode::ParallelType a) = FloatVectorHelpers::isAligned (dest) ? Mode::storeA  : Mode::storeU;   \

  145.             JUCE_VEC_LOOP_TWO_SOURCES (vecOp, loadSrc1, loadSrc2, storeDst, locals, increment);                                                \

  146.         } \

  147.         JUCE_FINISH_VEC_OP (normalOp)

  148. 

  149.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST(normalOp, vecOp, locals, increment, setupOp) \

  150.         JUCE_BEGIN_VEC_OP \

  151.         setupOp \

  152.         { \

  153.             Mode::ParallelType (&loadSrc1) (const Mode::Type* v) = FloatVectorHelpers::isAligned (src1) ? Mode::loadA  : Mode::loadU;          \

  154.             Mode::ParallelType (&loadSrc2) (const Mode::Type* v) = FloatVectorHelpers::isAligned (src2) ? Mode::loadA  : Mode::loadU;          \

  155.             Mode::ParallelType (&loadDst)  (const Mode::Type* v) = FloatVectorHelpers::isAligned (dest) ? Mode::loadA  : Mode::loadU;          \

  156.             void (&storeDst) (Mode::Type* dest, Mode::ParallelType a) = FloatVectorHelpers::isAligned (dest) ? Mode::storeA  : Mode::storeU;   \

  157.             JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, loadSrc1, loadSrc2, loadDst, storeDst, locals, increment);                        \

  158.         } \

  159.         JUCE_FINISH_VEC_OP (normalOp)

  160. 

  161. 

  162.     //==============================================================================

  163.    #elif JUCE_USE_ARM_NEON

  164. 

  165.     struct BasicOps32

  166.     {

  167.         typedef float Type;

  168.         typedef float32x4_t ParallelType;

  169.         enum { numParallel = 4 };

  170. 

  171.         static forcedinline ParallelType load1 (Type v) noexcept                        { return vld1q_dup_f32 (&v); }

  172.         static forcedinline ParallelType loadA (const Type* v) noexcept                 { return vld1q_f32 (v); }

  173.         static forcedinline ParallelType loadU (const Type* v) noexcept                 { return vld1q_f32 (v); }

  174.         static forcedinline void storeA (Type* dest, ParallelType a) noexcept           { vst1q_f32 (dest, a); }

  175.         static forcedinline void storeU (Type* dest, ParallelType a) noexcept           { vst1q_f32 (dest, a); }

  176. 

  177.         static forcedinline ParallelType add (ParallelType a, ParallelType b) noexcept  { return vaddq_f32 (a, b); }

  178.         static forcedinline ParallelType sub (ParallelType a, ParallelType b) noexcept  { return vsubq_f32 (a, b); }

  179.         static forcedinline ParallelType mul (ParallelType a, ParallelType b) noexcept  { return vmulq_f32 (a, b); }

  180.         static forcedinline ParallelType max (ParallelType a, ParallelType b) noexcept  { return vmaxq_f32 (a, b); }

  181.         static forcedinline ParallelType min (ParallelType a, ParallelType b) noexcept  { return vminq_f32 (a, b); }

  182. 

  183.         static forcedinline Type max (ParallelType a) noexcept { Type v[numParallel]; storeU (v, a); return jmax (v[0], v[1], v[2], v[3]); }

  184.         static forcedinline Type min (ParallelType a) noexcept { Type v[numParallel]; storeU (v, a); return jmin (v[0], v[1], v[2], v[3]); }

  185.     };

  186. 

  187.     struct BasicOps64

  188.     {

  189.         typedef double Type;

  190.         typedef double ParallelType;

  191.         enum { numParallel = 1 };

  192. 

  193.         static forcedinline ParallelType load1 (Type v) noexcept                        { return v; }

  194.         static forcedinline ParallelType loadA (const Type* v) noexcept                 { return *v; }

  195.         static forcedinline ParallelType loadU (const Type* v) noexcept                 { return *v; }

  196.         static forcedinline void storeA (Type* dest, ParallelType a) noexcept           { *dest = a; }

  197.         static forcedinline void storeU (Type* dest, ParallelType a) noexcept           { *dest = a; }

  198. 

  199.         static forcedinline ParallelType add (ParallelType a, ParallelType b) noexcept  { return a + b; }

  200.         static forcedinline ParallelType sub (ParallelType a, ParallelType b) noexcept  { return a - b; }

  201.         static forcedinline ParallelType mul (ParallelType a, ParallelType b) noexcept  { return a * b; }

  202.         static forcedinline ParallelType max (ParallelType a, ParallelType b) noexcept  { return jmax (a, b); }

  203.         static forcedinline ParallelType min (ParallelType a, ParallelType b) noexcept  { return jmin (a, b); }

  204. 

  205.         static forcedinline Type max (ParallelType a) noexcept  { return a; }

  206.         static forcedinline Type min (ParallelType a) noexcept  { return a; }

  207.     };

  208. 

  209.     #define JUCE_BEGIN_VEC_OP \

  210.         typedef FloatVectorHelpers::ModeType<sizeof(*dest)>::Mode Mode; \

  211.         if (Mode::numParallel > 1) \

  212.         { \

  213.             const int numLongOps = num / Mode::numParallel;

  214. 

  215.     #define JUCE_FINISH_VEC_OP(normalOp) \

  216.             num &= (Mode::numParallel - 1); \

  217.             if (num == 0) return; \

  218.         } \

  219.         for (int i = 0; i < num; ++i) normalOp;

  220. 

  221.     #define JUCE_PERFORM_VEC_OP_DEST(normalOp, vecOp, locals, setupOp) \

  222.         JUCE_BEGIN_VEC_OP \

  223.         setupOp \

  224.         JUCE_VEC_LOOP (vecOp, dummy, Mode::loadU, Mode::storeU, locals, JUCE_INCREMENT_DEST) \

  225.         JUCE_FINISH_VEC_OP (normalOp)

  226. 

  227.     #define JUCE_PERFORM_VEC_OP_SRC_DEST(normalOp, vecOp, locals, increment, setupOp) \

  228.         JUCE_BEGIN_VEC_OP \

  229.         setupOp \

  230.         JUCE_VEC_LOOP (vecOp, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  231.         JUCE_FINISH_VEC_OP (normalOp)

  232. 

  233.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST(normalOp, vecOp, locals, increment, setupOp) \

  234.         JUCE_BEGIN_VEC_OP \

  235.         setupOp \

  236.         JUCE_VEC_LOOP_TWO_SOURCES (vecOp, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  237.         JUCE_FINISH_VEC_OP (normalOp)

  238. 

  239.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST(normalOp, vecOp, locals, increment, setupOp) \

  240.         JUCE_BEGIN_VEC_OP \

  241.         setupOp \

  242.         JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, Mode::loadU, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  243.         JUCE_FINISH_VEC_OP (normalOp)

  244. 

  245. 

  246.     //==============================================================================

  247.    #else

  248.     #define JUCE_PERFORM_VEC_OP_DEST(normalOp, vecOp, locals, setupOp) \

  249.         for (int i = 0; i < num; ++i) normalOp;

  250. 

  251.     #define JUCE_PERFORM_VEC_OP_SRC_DEST(normalOp, vecOp, locals, increment, setupOp) \

  252.         for (int i = 0; i < num; ++i) normalOp;

  253. 

  254.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST(normalOp, vecOp, locals, increment, setupOp) \

  255.         for (int i = 0; i < num; ++i) normalOp;

  256. 

  257.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST(normalOp, vecOp, locals, increment, setupOp) \

  258.         for (int i = 0; i < num; ++i) normalOp;

  259. 

  260.    #endif

  261. 

  262.     //==============================================================================

  263.     #define JUCE_VEC_LOOP(vecOp, srcLoad, dstLoad, dstStore, locals, increment) \

  264.         for (int i = 0; i < numLongOps; ++i) \

  265.         { \

  266.             locals (srcLoad, dstLoad); \

  267.             dstStore (dest, vecOp); \

  268.             increment; \

  269.         }

  270. 

  271.     #define JUCE_VEC_LOOP_TWO_SOURCES(vecOp, src1Load, src2Load, dstStore, locals, increment) \

  272.         for (int i = 0; i < numLongOps; ++i) \

  273.         { \

  274.             locals (src1Load, src2Load); \

  275.             dstStore (dest, vecOp); \

  276.             increment; \

  277.         }

  278. 

  279.     #define JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD(vecOp, src1Load, src2Load, dstLoad, dstStore, locals, increment) \

  280.         for (int i = 0; i < numLongOps; ++i) \

  281.         { \

  282.             locals (src1Load, src2Load, dstLoad); \

  283.             dstStore (dest, vecOp); \

  284.             increment; \

  285.         }

  286. 

  287.     #define JUCE_LOAD_NONE(srcLoad, dstLoad)

  288.     #define JUCE_LOAD_DEST(srcLoad, dstLoad)                        const Mode::ParallelType d = dstLoad (dest);

  289.     #define JUCE_LOAD_SRC(srcLoad, dstLoad)                         const Mode::ParallelType s = srcLoad (src);

  290.     #define JUCE_LOAD_SRC1_SRC2(src1Load, src2Load)                 const Mode::ParallelType s1 = src1Load (src1), s2 = src2Load (src2);

  291.     #define JUCE_LOAD_SRC1_SRC2_DEST(src1Load, src2Load, dstLoad)   const Mode::ParallelType d = dstLoad (dest), s1 = src1Load (src1), s2 = src2Load (src2);

  292.     #define JUCE_LOAD_SRC_DEST(srcLoad, dstLoad)                    const Mode::ParallelType d = dstLoad (dest), s = srcLoad (src);

  293. 

  294.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  295.     template<int typeSize> struct ModeType    { typedef BasicOps32 Mode; };

  296.     template<>             struct ModeType<8> { typedef BasicOps64 Mode; };

  297. 

  298.     template <typename Mode>

  299.     struct MinMax

  300.     {

  301.         typedef typename Mode::Type Type;

  302.         typedef typename Mode::ParallelType ParallelType;

  303. 

  304.         static Type findMinOrMax (const Type* src, int num, const bool isMinimum) noexcept

  305.         {

  306.             int numLongOps = num / Mode::numParallel;

  307. 

  308.            #if JUCE_USE_SSE_INTRINSICS

  309.             if (numLongOps > 1 && isSSE2Available())

  310.            #else

  311.             if (numLongOps > 1)

  312.            #endif

  313.             {

  314.                 ParallelType val;

  315. 

  316.                #if ! JUCE_USE_ARM_NEON

  317.                 if (isAligned (src))

  318.                 {

  319.                     val = Mode::loadA (src);

  320. 

  321.                     if (isMinimum)

  322.                     {

  323.                         while (--numLongOps > 0)

  324.                         {

  325.                             src += Mode::numParallel;

  326.                             val = Mode::min (val, Mode::loadA (src));

  327.                         }

  328.                     }

  329.                     else

  330.                     {

  331.                         while (--numLongOps > 0)

  332.                         {

  333.                             src += Mode::numParallel;

  334.                             val = Mode::max (val, Mode::loadA (src));

  335.                         }

  336.                     }

  337.                 }

  338.                 else

  339.                #endif

  340.                 {

  341.                     val = Mode::loadU (src);

  342. 

  343.                     if (isMinimum)

  344.                     {

  345.                         while (--numLongOps > 0)

  346.                         {

  347.                             src += Mode::numParallel;

  348.                             val = Mode::min (val, Mode::loadU (src));

  349.                         }

  350.                     }

  351.                     else

  352.                     {

  353.                         while (--numLongOps > 0)

  354.                         {

  355.                             src += Mode::numParallel;

  356.                             val = Mode::max (val, Mode::loadU (src));

  357.                         }

  358.                     }

  359.                 }

  360. 

  361.                 Type result = isMinimum ? Mode::min (val)

  362.                                         : Mode::max (val);

  363. 

  364.                 num &= (Mode::numParallel - 1);

  365.                 src += Mode::numParallel;

  366. 

  367.                 for (int i = 0; i < num; ++i)

  368.                     result = isMinimum ? jmin (result, src[i])

  369.                                        : jmax (result, src[i]);

  370. 

  371.                 return result;

  372.             }

  373. 

  374.             return isMinimum ? juce::findMinimum (src, num)

  375.                              : juce::findMaximum (src, num);

  376.         }

  377. 

  378.         static Range<Type> findMinAndMax (const Type* src, int num) noexcept

  379.         {

  380.             int numLongOps = num / Mode::numParallel;

  381. 

  382.            #if JUCE_USE_SSE_INTRINSICS

  383.             if (numLongOps > 1 && isSSE2Available())

  384.            #else

  385.             if (numLongOps > 1)

  386.            #endif

  387.             {

  388.                 ParallelType mn, mx;

  389. 

  390.                #if ! JUCE_USE_ARM_NEON

  391.                 if (isAligned (src))

  392.                 {

  393.                     mn = Mode::loadA (src);

  394.                     mx = mn;

  395. 

  396.                     while (--numLongOps > 0)

  397.                     {

  398.                         src += Mode::numParallel;

  399.                         const ParallelType v = Mode::loadA (src);

  400.                         mn = Mode::min (mn, v);

  401.                         mx = Mode::max (mx, v);

  402.                     }

  403.                 }

  404.                 else

  405.                #endif

  406.                 {

  407.                     mn = Mode::loadU (src);

  408.                     mx = mn;

  409. 

  410.                     while (--numLongOps > 0)

  411.                     {

  412.                         src += Mode::numParallel;

  413.                         const ParallelType v = Mode::loadU (src);

  414.                         mn = Mode::min (mn, v);

  415.                         mx = Mode::max (mx, v);

  416.                     }

  417.                 }

  418. 

  419.                 Range<Type> result (Mode::min (mn),

  420.                                     Mode::max (mx));

  421. 

  422.                 num &= (Mode::numParallel - 1);

  423.                 src += Mode::numParallel;

  424. 

  425.                 for (int i = 0; i < num; ++i)

  426.                     result = result.getUnionWith (src[i]);

  427. 

  428.                 return result;

  429.             }

  430. 

  431.             return Range<Type>::findMinAndMax (src, num);

  432.         }

  433.     };

  434.    #endif

  435. }

  436. 

  437. //==============================================================================

  438. void JUCE_CALLTYPE FloatVectorOperations::clear (float* dest, int num) noexcept

  439. {

  440.    #if JUCE_USE_VDSP_FRAMEWORK

  441.     vDSP_vclr (dest, 1, (size_t) num);

  442.    #else

  443.     zeromem (dest, num * sizeof (float));

  444.    #endif

  445. }

  446. 

  447. void JUCE_CALLTYPE FloatVectorOperations::clear (double* dest, int num) noexcept

  448. {

  449.    #if JUCE_USE_VDSP_FRAMEWORK

  450.     vDSP_vclrD (dest, 1, (size_t) num);

  451.    #else

  452.     zeromem (dest, num * sizeof (double));

  453.    #endif

  454. }

  455. 

  456. void JUCE_CALLTYPE FloatVectorOperations::fill (float* dest, float valueToFill, int num) noexcept

  457. {

  458.    #if JUCE_USE_VDSP_FRAMEWORK

  459.     vDSP_vfill (&valueToFill, dest, 1, (size_t) num);

  460.    #else

  461.     JUCE_PERFORM_VEC_OP_DEST (dest[i] = valueToFill, val, JUCE_LOAD_NONE,

  462.                               const Mode::ParallelType val = Mode::load1 (valueToFill);)

  463.    #endif

  464. }

  465. 

  466. void JUCE_CALLTYPE FloatVectorOperations::fill (double* dest, double valueToFill, int num) noexcept

  467. {

  468.    #if JUCE_USE_VDSP_FRAMEWORK

  469.     vDSP_vfillD (&valueToFill, dest, 1, (size_t) num);

  470.    #else

  471.     JUCE_PERFORM_VEC_OP_DEST (dest[i] = valueToFill, val, JUCE_LOAD_NONE,

  472.                               const Mode::ParallelType val = Mode::load1 (valueToFill);)

  473.    #endif

  474. }

  475. 

  476. void JUCE_CALLTYPE FloatVectorOperations::copy (float* dest, const float* src, int num) noexcept

  477. {

  478.     memcpy (dest, src, (size_t) num * sizeof (float));

  479. }

  480. 

  481. void JUCE_CALLTYPE FloatVectorOperations::copy (double* dest, const double* src, int num) noexcept

  482. {

  483.     memcpy (dest, src, (size_t) num * sizeof (double));

  484. }

  485. 

  486. void JUCE_CALLTYPE FloatVectorOperations::copyWithMultiply (float* dest, const float* src, float multiplier, int num) noexcept

  487. {

  488.    #if JUCE_USE_VDSP_FRAMEWORK

  489.     vDSP_vsmul (src, 1, &multiplier, dest, 1, (vDSP_Length) num);

  490.    #else

  491.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier, Mode::mul (mult, s),

  492.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  493.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  494.    #endif

  495. }

  496. 

  497. void JUCE_CALLTYPE FloatVectorOperations::copyWithMultiply (double* dest, const double* src, double multiplier, int num) noexcept

  498. {

  499.    #if JUCE_USE_VDSP_FRAMEWORK

  500.     vDSP_vsmulD (src, 1, &multiplier, dest, 1, (vDSP_Length) num);

  501.    #else

  502.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier, Mode::mul (mult, s),

  503.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  504.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  505.    #endif

  506. }

  507. 

  508. void JUCE_CALLTYPE FloatVectorOperations::add (float* dest, float amount, int num) noexcept

  509. {

  510.    #if JUCE_USE_VDSP_FRAMEWORK

  511.     vDSP_vsadd (dest, 1, &amount, dest, 1, (vDSP_Length) num);

  512.    #else

  513.     JUCE_PERFORM_VEC_OP_DEST (dest[i] += amount, Mode::add (d, amountToAdd), JUCE_LOAD_DEST,

  514.                               const Mode::ParallelType amountToAdd = Mode::load1 (amount);)

  515.    #endif

  516. }

  517. 

  518. void JUCE_CALLTYPE FloatVectorOperations::add (double* dest, double amount, int num) noexcept

  519. {

  520.     JUCE_PERFORM_VEC_OP_DEST (dest[i] += amount, Mode::add (d, amountToAdd), JUCE_LOAD_DEST,

  521.                               const Mode::ParallelType amountToAdd = Mode::load1 (amount);)

  522. }

  523. 

  524. void JUCE_CALLTYPE FloatVectorOperations::add (float* dest, float* src, float amount, int num) noexcept

  525. {

  526.    #if JUCE_USE_VDSP_FRAMEWORK

  527.     vDSP_vsadd (src, 1, &amount, dest, 1, (vDSP_Length) num);

  528.    #else

  529.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] + amount, Mode::add (am, s),

  530.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  531.                                   const Mode::ParallelType am = Mode::load1 (amount);)

  532.    #endif

  533. }

  534. 

  535. void JUCE_CALLTYPE FloatVectorOperations::add (double* dest, double* src, double amount, int num) noexcept

  536. {

  537.    #if JUCE_USE_VDSP_FRAMEWORK

  538.     vDSP_vsaddD (src, 1, &amount, dest, 1, (vDSP_Length) num);

  539.    #else

  540.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] + amount, Mode::add (am, s),

  541.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  542.                                   const Mode::ParallelType am = Mode::load1 (amount);)

  543.    #endif

  544. }

  545. 

  546. void JUCE_CALLTYPE FloatVectorOperations::add (float* dest, const float* src, int num) noexcept

  547. {

  548.    #if JUCE_USE_VDSP_FRAMEWORK

  549.     vDSP_vadd (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  550.    #else

  551.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] += src[i], Mode::add (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  552.    #endif

  553. }

  554. 

  555. void JUCE_CALLTYPE FloatVectorOperations::add (double* dest, const double* src, int num) noexcept

  556. {

  557.    #if JUCE_USE_VDSP_FRAMEWORK

  558.     vDSP_vaddD (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  559.    #else

  560.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] += src[i], Mode::add (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  561.    #endif

  562. }

  563. 

  564. void JUCE_CALLTYPE FloatVectorOperations::add (float* dest, const float* src1, const float* src2, int num) noexcept

  565. {

  566.    #if JUCE_USE_VDSP_FRAMEWORK

  567.     vDSP_vadd (src1, 1, src2, 1, dest, 1, (vDSP_Length) num);

  568.    #else

  569.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] + src2[i], Mode::add (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  570.    #endif

  571. }

  572. 

  573. void JUCE_CALLTYPE FloatVectorOperations::add (double* dest, const double* src1, const double* src2, int num) noexcept

  574. {

  575.    #if JUCE_USE_VDSP_FRAMEWORK

  576.     vDSP_vaddD (src1, 1, src2, 1, dest, 1, (vDSP_Length) num);

  577.    #else

  578.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] + src2[i], Mode::add (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  579.    #endif

  580. }

  581. 

  582. void JUCE_CALLTYPE FloatVectorOperations::subtract (float* dest, const float* src, int num) noexcept

  583. {

  584.    #if JUCE_USE_VDSP_FRAMEWORK

  585.     vDSP_vsub (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  586.    #else

  587.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] -= src[i], Mode::sub (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  588.    #endif

  589. }

  590. 

  591. void JUCE_CALLTYPE FloatVectorOperations::subtract (double* dest, const double* src, int num) noexcept

  592. {

  593.    #if JUCE_USE_VDSP_FRAMEWORK

  594.     vDSP_vsubD (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  595.    #else

  596.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] -= src[i], Mode::sub (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  597.    #endif

  598. }

  599. 

  600. void JUCE_CALLTYPE FloatVectorOperations::subtract (float* dest, const float* src1, const float* src2, int num) noexcept

  601. {

  602.    #if JUCE_USE_VDSP_FRAMEWORK

  603.     vDSP_vsub (src2, 1, src1, 1, dest, 1, (vDSP_Length) num);

  604.    #else

  605.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] - src2[i], Mode::sub (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  606.    #endif

  607. }

  608. 

  609. void JUCE_CALLTYPE FloatVectorOperations::subtract (double* dest, const double* src1, const double* src2, int num) noexcept

  610. {

  611.    #if JUCE_USE_VDSP_FRAMEWORK

  612.     vDSP_vsubD (src2, 1, src1, 1, dest, 1, (vDSP_Length) num);

  613.    #else

  614.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] - src2[i], Mode::sub (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  615.    #endif

  616. }

  617. 

  618. void JUCE_CALLTYPE FloatVectorOperations::addWithMultiply (float* dest, const float* src, float multiplier, int num) noexcept

  619. {

  620.    #if JUCE_USE_VDSP_FRAMEWORK

  621.     vDSP_vsma (src, 1, &multiplier, dest, 1, dest, 1, (vDSP_Length) num);

  622.    #else

  623.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] += src[i] * multiplier, Mode::add (d, Mode::mul (mult, s)),

  624.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

  625.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  626.    #endif

  627. }

  628. 

  629. void JUCE_CALLTYPE FloatVectorOperations::addWithMultiply (double* dest, const double* src, double multiplier, int num) noexcept

  630. {

  631.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] += src[i] * multiplier, Mode::add (d, Mode::mul (mult, s)),

  632.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

  633.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  634. }

  635. 

  636. void JUCE_CALLTYPE FloatVectorOperations::addWithMultiply (float* dest, const float* src1, const float* src2, int num) noexcept

  637. {

  638.    #if JUCE_USE_VDSP_FRAMEWORK

  639.     vDSP_vma ((float*) src1, 1, (float*) src2, 1, dest, 1, dest, 1, (vDSP_Length) num);

  640.    #else

  641.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST (dest[i] += src1[i] * src2[i], Mode::add (d, Mode::mul (s1, s2)),

  642.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  643.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  644.    #endif

  645. }

  646. 

  647. void JUCE_CALLTYPE FloatVectorOperations::addWithMultiply (double* dest, const double* src1, const double* src2, int num) noexcept

  648. {

  649.    #if JUCE_USE_VDSP_FRAMEWORK

  650.     vDSP_vmaD ((double*) src1, 1, (double*) src2, 1, dest, 1, dest, 1, (vDSP_Length) num);

  651.    #else

  652.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST (dest[i] += src1[i] * src2[i], Mode::add (d, Mode::mul (s1, s2)),

  653.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  654.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  655.    #endif

  656. }

  657. 

  658. void JUCE_CALLTYPE FloatVectorOperations::multiply (float* dest, const float* src, int num) noexcept

  659. {

  660.    #if JUCE_USE_VDSP_FRAMEWORK

  661.     vDSP_vmul (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  662.    #else

  663.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] *= src[i], Mode::mul (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  664.    #endif

  665. }

  666. 

  667. void JUCE_CALLTYPE FloatVectorOperations::multiply (double* dest, const double* src, int num) noexcept

  668. {

  669.    #if JUCE_USE_VDSP_FRAMEWORK

  670.     vDSP_vmulD (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  671.    #else

  672.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] *= src[i], Mode::mul (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  673.    #endif

  674. }

  675. 

  676. void JUCE_CALLTYPE FloatVectorOperations::multiply (float* dest, const float* src1, const float* src2, int num) noexcept

  677. {

  678.    #if JUCE_USE_VDSP_FRAMEWORK

  679.     vDSP_vmul (src1, 1, src2, 1, dest, 1, (vDSP_Length) num);

  680.    #else

  681.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] * src2[i], Mode::mul (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  682.    #endif

  683. }

  684. 

  685. void JUCE_CALLTYPE FloatVectorOperations::multiply (double* dest, const double* src1, const double* src2, int num) noexcept

  686. {

  687.    #if JUCE_USE_VDSP_FRAMEWORK

  688.     vDSP_vmulD (src1, 1, src2, 1, dest, 1, (vDSP_Length) num);

  689.    #else

  690.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] * src2[i], Mode::mul (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  691.    #endif

  692. }

  693. 

  694. void JUCE_CALLTYPE FloatVectorOperations::multiply (float* dest, float multiplier, int num) noexcept

  695. {

  696.    #if JUCE_USE_VDSP_FRAMEWORK

  697.     vDSP_vsmul (dest, 1, &multiplier, dest, 1, (vDSP_Length) num);

  698.    #else

  699.     JUCE_PERFORM_VEC_OP_DEST (dest[i] *= multiplier, Mode::mul (d, mult), JUCE_LOAD_DEST,

  700.                               const Mode::ParallelType mult = Mode::load1 (multiplier);)

  701.    #endif

  702. }

  703. 

  704. void JUCE_CALLTYPE FloatVectorOperations::multiply (double* dest, double multiplier, int num) noexcept

  705. {

  706.    #if JUCE_USE_VDSP_FRAMEWORK

  707.     vDSP_vsmulD (dest, 1, &multiplier, dest, 1, (vDSP_Length) num);

  708.    #else

  709.     JUCE_PERFORM_VEC_OP_DEST (dest[i] *= multiplier, Mode::mul (d, mult), JUCE_LOAD_DEST,

  710.                               const Mode::ParallelType mult = Mode::load1 (multiplier);)

  711.    #endif

  712. }

  713. 

  714. void JUCE_CALLTYPE FloatVectorOperations::multiply (float* dest, const float* src, float multiplier, int num) noexcept

  715. {

  716.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier, Mode::mul (mult, s),

  717.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  718.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  719. }

  720. 

  721. void JUCE_CALLTYPE FloatVectorOperations::multiply (double* dest, const double* src, double multiplier, int num) noexcept

  722. {

  723.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier, Mode::mul (mult, s),

  724.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  725.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  726. }

  727. 

  728. void FloatVectorOperations::negate (float* dest, const float* src, int num) noexcept

  729. {

  730.    #if JUCE_USE_VDSP_FRAMEWORK

  731.     vDSP_vneg ((float*) src, 1, dest, 1, (vDSP_Length) num);

  732.    #else

  733.     copyWithMultiply (dest, src, -1.0f, num);

  734.    #endif

  735. }

  736. 

  737. void FloatVectorOperations::negate (double* dest, const double* src, int num) noexcept

  738. {

  739.    #if JUCE_USE_VDSP_FRAMEWORK

  740.     vDSP_vnegD ((double*) src, 1, dest, 1, (vDSP_Length) num);

  741.    #else

  742.     copyWithMultiply (dest, src, -1.0f, num);

  743.    #endif

  744. }

  745. 

  746. void FloatVectorOperations::abs (float* dest, const float* src, int num) noexcept

  747. {

  748.    #if JUCE_USE_VDSP_FRAMEWORK

  749.     vDSP_vabs ((float*) src, 1, dest, 1, (vDSP_Length) num);

  750.    #else

  751.     union {float f; uint32 i;} signMask;

  752.     signMask.i = 0x80000000UL;

  753.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = fabsf(src[i]),

  754.                                   Mode::bit_xor (s, Mode::bit_and (s, mask)),

  755.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST, 

  756.                                   const Mode::ParallelType mask = Mode::load1 (signMask.f);)

  757.    #endif

  758. }

  759. 

  760. void FloatVectorOperations::abs (double* dest, const double* src, int num) noexcept

  761. {

  762.    #if JUCE_USE_VDSP_FRAMEWORK

  763.     vDSP_vabsD ((double*) src, 1, dest, 1, (vDSP_Length) num);

  764.    #else

  765.     union {double d; uint64 i;} signMask;

  766.     signMask.i = 0x8000000000000000ULL;

  767. 

  768.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = fabs (src[i]),

  769.                                   Mode::bit_xor (s, Mode::bit_and (s, mask)),

  770.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST, 

  771.                                   const Mode::ParallelType mask = Mode::load1 (signMask.d);)

  772.    #endif

  773. }

  774. 

  775. void JUCE_CALLTYPE FloatVectorOperations::convertFixedToFloat (float* dest, const int* src, float multiplier, int num) noexcept

  776. {

  777.    #if JUCE_USE_ARM_NEON

  778.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier,

  779.                                   vmulq_n_f32 (vcvtq_f32_s32 (vld1q_s32 (src)), multiplier),

  780.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST, )

  781.    #else

  782.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier,

  783.                                   Mode::mul (mult, _mm_cvtepi32_ps (_mm_loadu_si128 ((const __m128i*) src))),

  784.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST,

  785.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  786.    #endif

  787. }

  788. 

  789. void JUCE_CALLTYPE FloatVectorOperations::min (float* dest, const float* src, float comp, int num) noexcept

  790. {

  791.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmin (src[i], comp), Mode::min (s, cmp),

  792.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  793.                                   const Mode::ParallelType cmp = Mode::load1 (comp);)

  794. }

  795. 

  796. void JUCE_CALLTYPE FloatVectorOperations::min (double* dest, const double* src, double comp, int num) noexcept

  797. {

  798.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmin (src[i], comp), Mode::min (s, cmp),

  799.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  800.                                   const Mode::ParallelType cmp = Mode::load1 (comp);)

  801. }

  802. 

  803. void JUCE_CALLTYPE FloatVectorOperations::min (float* dest, const float* src1, const float* src2, int num) noexcept

  804. {

  805.    #if JUCE_USE_VDSP_FRAMEWORK

  806.     vDSP_vmin ((float*) src1, 1, (float*) src2, 1, dest, 1, (vDSP_Length) num);

  807.    #else

  808.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = jmin (src1[i], src2[i]), Mode::min (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  809.    #endif

  810. }

  811. 

  812. void JUCE_CALLTYPE FloatVectorOperations::min (double* dest, const double* src1, const double* src2, int num) noexcept

  813. {

  814.    #if JUCE_USE_VDSP_FRAMEWORK

  815.     vDSP_vminD ((double*) src1, 1, (double*) src2, 1, dest, 1, (vDSP_Length) num);

  816.    #else

  817.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = jmin (src1[i], src2[i]), Mode::min (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  818.    #endif

  819. }

  820. 

  821. void JUCE_CALLTYPE FloatVectorOperations::max (float* dest, const float* src, float comp, int num) noexcept

  822. {

  823.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmax (src[i], comp), Mode::max (s, cmp),

  824.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  825.                                   const Mode::ParallelType cmp = Mode::load1 (comp);)

  826. }

  827. 

  828. void JUCE_CALLTYPE FloatVectorOperations::max (double* dest, const double* src, double comp, int num) noexcept

  829. {

  830.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmax (src[i], comp), Mode::max (s, cmp),

  831.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  832.                                   const Mode::ParallelType cmp = Mode::load1 (comp);)

  833. }

  834. 

  835. void JUCE_CALLTYPE FloatVectorOperations::max (float* dest, const float* src1, const float* src2, int num) noexcept

  836. {

  837.    #if JUCE_USE_VDSP_FRAMEWORK

  838.     vDSP_vmax ((float*) src1, 1, (float*) src2, 1, dest, 1, (vDSP_Length) num);

  839.    #else

  840.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = jmax (src1[i], src2[i]), Mode::max (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  841.    #endif

  842. }

  843. 

  844. void JUCE_CALLTYPE FloatVectorOperations::max (double* dest, const double* src1, const double* src2, int num) noexcept

  845. {

  846.    #if JUCE_USE_VDSP_FRAMEWORK

  847.     vDSP_vmaxD ((double*) src1, 1, (double*) src2, 1, dest, 1, (vDSP_Length) num);

  848.    #else

  849.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = jmax (src1[i], src2[i]), Mode::max (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  850.    #endif

  851. }

  852. 

  853. void JUCE_CALLTYPE FloatVectorOperations::clip (float* dest, const float* src, float low, float high, int num) noexcept

  854. {

  855.     jassert(high >= low);

  856. 

  857.    #if JUCE_USE_VDSP_FRAMEWORK

  858.     vDSP_vclip ((float*) src, 1, &low, &high, dest, 1, (vDSP_Length) num);

  859.    #else

  860.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmax (jmin (src[i], high), low), Mode::max (Mode::min (s, hi), lo),

  861.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  862.                                   const Mode::ParallelType lo = Mode::load1 (low); const Mode::ParallelType hi = Mode::load1 (high);)

  863.    #endif

  864. }

  865. 

  866. void JUCE_CALLTYPE FloatVectorOperations::clip (double* dest, const double* src, double low, double high, int num) noexcept

  867. {

  868.     jassert(high >= low);

  869. 

  870.    #if JUCE_USE_VDSP_FRAMEWORK

  871.     vDSP_vclipD ((double*) src, 1, &low, &high, dest, 1, (vDSP_Length) num);

  872.    #else

  873.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmax (jmin (src[i], high), low), Mode::max (Mode::min (s, hi), lo),

  874.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  875.                                   const Mode::ParallelType lo = Mode::load1 (low); const Mode::ParallelType hi = Mode::load1 (high);)

  876.    #endif

  877. }

  878. 

  879. Range<float> JUCE_CALLTYPE FloatVectorOperations::findMinAndMax (const float* src, int num) noexcept

  880. {

  881.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  882.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps32>::findMinAndMax (src, num);

  883.    #else

  884.     return Range<float>::findMinAndMax (src, num);

  885.    #endif

  886. }

  887. 

  888. Range<double> JUCE_CALLTYPE FloatVectorOperations::findMinAndMax (const double* src, int num) noexcept

  889. {

  890.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  891.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps64>::findMinAndMax (src, num);

  892.    #else

  893.     return Range<double>::findMinAndMax (src, num);

  894.    #endif

  895. }

  896. 

  897. float JUCE_CALLTYPE FloatVectorOperations::findMinimum (const float* src, int num) noexcept

  898. {

  899.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  900.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps32>::findMinOrMax (src, num, true);

  901.    #else

  902.     return juce::findMinimum (src, num);

  903.    #endif

  904. }

  905. 

  906. double JUCE_CALLTYPE FloatVectorOperations::findMinimum (const double* src, int num) noexcept

  907. {

  908.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  909.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps64>::findMinOrMax (src, num, true);

  910.    #else

  911.     return juce::findMinimum (src, num);

  912.    #endif

  913. }

  914. 

  915. float JUCE_CALLTYPE FloatVectorOperations::findMaximum (const float* src, int num) noexcept

  916. {

  917.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  918.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps32>::findMinOrMax (src, num, false);

  919.    #else

  920.     return juce::findMaximum (src, num);

  921.    #endif

  922. }

  923. 

  924. double JUCE_CALLTYPE FloatVectorOperations::findMaximum (const double* src, int num) noexcept

  925. {

  926.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  927.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps64>::findMinOrMax (src, num, false);

  928.    #else

  929.     return juce::findMaximum (src, num);

  930.    #endif

  931. }

  932. 

  933. void JUCE_CALLTYPE FloatVectorOperations::enableFlushToZeroMode (bool shouldEnable) noexcept

  934. {

  935.    #if JUCE_USE_SSE_INTRINSICS

  936.     if (FloatVectorHelpers::isSSE2Available())

  937.         _MM_SET_FLUSH_ZERO_MODE (shouldEnable ? _MM_FLUSH_ZERO_ON : _MM_FLUSH_ZERO_OFF);

  938.    #endif

  939.     (void) shouldEnable;

  940. }

  941. 

  942. //==============================================================================

  943. //==============================================================================

  944. #if JUCE_UNIT_TESTS

  945. 

  946. class FloatVectorOperationsTests  : public UnitTest

  947. {

  948. public:

  949.     FloatVectorOperationsTests() : UnitTest ("FloatVectorOperations") {}

  950. 

  951.     template <typename ValueType>

  952.     struct TestRunner

  953.     {

  954.         static void runTest (UnitTest& u, Random random)

  955.         {

  956.             const int range = random.nextBool() ? 500 : 10;

  957.             const int num = random.nextInt (range) + 1;

  958. 

  959.             HeapBlock<ValueType> buffer1 ((size_t) num + 16), buffer2 ((size_t) num + 16);

  960.             HeapBlock<int> buffer3 ((size_t) num + 16);

  961. 

  962.            #if JUCE_ARM

  963.             ValueType* const data1 = buffer1;

  964.             ValueType* const data2 = buffer2;

  965.             int* const int1 = buffer3;

  966.            #else

  967.             ValueType* const data1 = addBytesToPointer (buffer1.getData(), random.nextInt (16));

  968.             ValueType* const data2 = addBytesToPointer (buffer2.getData(), random.nextInt (16));

  969.             int* const int1 = addBytesToPointer (buffer3.getData(), random.nextInt (16));

  970.            #endif

  971. 

  972.             fillRandomly (random, data1, num);

  973.             fillRandomly (random, data2, num);

  974. 

  975.             Range<ValueType> minMax1 (FloatVectorOperations::findMinAndMax (data1, num));

  976.             Range<ValueType> minMax2 (Range<ValueType>::findMinAndMax (data1, num));

  977.             u.expect (minMax1 == minMax2);

  978. 

  979.             u.expect (valuesMatch (FloatVectorOperations::findMinimum (data1, num), juce::findMinimum (data1, num)));

  980.             u.expect (valuesMatch (FloatVectorOperations::findMaximum (data1, num), juce::findMaximum (data1, num)));

  981. 

  982.             u.expect (valuesMatch (FloatVectorOperations::findMinimum (data2, num), juce::findMinimum (data2, num)));

  983.             u.expect (valuesMatch (FloatVectorOperations::findMaximum (data2, num), juce::findMaximum (data2, num)));

  984. 

  985.             FloatVectorOperations::clear (data1, num);

  986.             u.expect (areAllValuesEqual (data1, num, 0));

  987. 

  988.             FloatVectorOperations::fill (data1, (ValueType) 2, num);

  989.             u.expect (areAllValuesEqual (data1, num, (ValueType) 2));

  990. 

  991.             FloatVectorOperations::add (data1, (ValueType) 2, num);

  992.             u.expect (areAllValuesEqual (data1, num, (ValueType) 4));

  993. 

  994.             FloatVectorOperations::copy (data2, data1, num);

  995.             u.expect (areAllValuesEqual (data2, num, (ValueType) 4));

  996. 

  997.             FloatVectorOperations::add (data2, data1, num);

  998.             u.expect (areAllValuesEqual (data2, num, (ValueType) 8));

  999. 

  1000.             FloatVectorOperations::copyWithMultiply (data2, data1, (ValueType) 4, num);

  1001.             u.expect (areAllValuesEqual (data2, num, (ValueType) 16));

  1002. 

  1003.             FloatVectorOperations::addWithMultiply (data2, data1, (ValueType) 4, num);

  1004.             u.expect (areAllValuesEqual (data2, num, (ValueType) 32));

  1005. 

  1006.             FloatVectorOperations::multiply (data1, (ValueType) 2, num);

  1007.             u.expect (areAllValuesEqual (data1, num, (ValueType) 8));

  1008. 

  1009.             FloatVectorOperations::multiply (data1, data2, num);

  1010.             u.expect (areAllValuesEqual (data1, num, (ValueType) 256));

  1011. 

  1012.             FloatVectorOperations::negate (data2, data1, num);

  1013.             u.expect (areAllValuesEqual (data2, num, (ValueType) -256));

  1014. 

  1015.             FloatVectorOperations::subtract (data1, data2, num);

  1016.             u.expect (areAllValuesEqual (data1, num, (ValueType) 512));

  1017. 

  1018.             FloatVectorOperations::abs (data1, data2, num);

  1019.             u.expect (areAllValuesEqual (data1, num, (ValueType) 256));

  1020. 

  1021.             FloatVectorOperations::abs (data2, data1, num);

  1022.             u.expect (areAllValuesEqual (data2, num, (ValueType) 256));

  1023. 

  1024.             fillRandomly (random, int1, num);

  1025.             doConversionTest (u, data1, data2, int1, num);

  1026. 

  1027.             FloatVectorOperations::fill (data1, (ValueType) 2, num);

  1028.             FloatVectorOperations::fill (data2, (ValueType) 3, num);

  1029.             FloatVectorOperations::addWithMultiply (data1, data1, data2, num);

  1030.             u.expect (areAllValuesEqual (data1, num, (ValueType) 8));

  1031.         }

  1032. 

  1033.         static void doConversionTest (UnitTest& u, float* data1, float* data2, int* const int1, int num)

  1034.         {

  1035.             FloatVectorOperations::convertFixedToFloat (data1, int1, 2.0f, num);

  1036.             convertFixed (data2, int1, 2.0f, num);

  1037.             u.expect (buffersMatch (data1, data2, num));

  1038.         }

  1039. 

  1040.         static void doConversionTest (UnitTest&, double*, double*, int*, int) {}

  1041. 

  1042.         static void fillRandomly (Random& random, ValueType* d, int num)

  1043.         {

  1044.             while (--num >= 0)

  1045.                 *d++ = (ValueType) (random.nextDouble() * 1000.0);

  1046.         }

  1047. 

  1048.         static void fillRandomly (Random& random, int* d, int num)

  1049.         {

  1050.             while (--num >= 0)

  1051.                 *d++ = random.nextInt();

  1052.         }

  1053. 

  1054.         static void convertFixed (float* d, const int* s, ValueType multiplier, int num)

  1055.         {

  1056.             while (--num >= 0)

  1057.                 *d++ = *s++ * multiplier;

  1058.         }

  1059. 

  1060.         static bool areAllValuesEqual (const ValueType* d, int num, ValueType target)

  1061.         {

  1062.             while (--num >= 0)

  1063.                 if (*d++ != target)

  1064.                     return false;

  1065. 

  1066.             return true;

  1067.         }

  1068. 

  1069.         static bool buffersMatch (const ValueType* d1, const ValueType* d2, int num)

  1070.         {

  1071.             while (--num >= 0)

  1072.                 if (! valuesMatch (*d1++, *d2++))

  1073.                     return false;

  1074. 

  1075.             return true;

  1076.         }

  1077. 

  1078.         static bool valuesMatch (ValueType v1, ValueType v2)

  1079.         {

  1080.             return std::abs (v1 - v2) < std::numeric_limits<ValueType>::epsilon();

  1081.         }

  1082.     };

  1083. 

  1084.     void runTest()

  1085.     {

  1086.         beginTest ("FloatVectorOperations");

  1087. 

  1088.         for (int i = 1000; --i >= 0;)

  1089.         {

  1090.             TestRunner<float>::runTest (*this, getRandom());

  1091.             TestRunner<double>::runTest (*this, getRandom());

  1092.         }

  1093.     }

  1094. };

  1095. 

  1096. static FloatVectorOperationsTests vectorOpTests;

  1097. 

  1098. #endif