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.
5092 Commits
11 Branches
366MB
Tree: 63d16bb136
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '63d16bb136'
${ noResults }
JUCE/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp

1125 lines
50KB
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.         typedef __m128 IntegerType;

  53.         enum { numParallel = 4 };

  54. 

  55.         // Integer and parallel types are the same for SSE. On neon they have different types

  56.         static forcedinline IntegerType toint (ParallelType v) { return v; }

  57.         static forcedinline ParallelType toflt (IntegerType v) { return v; }

  58. 

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

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

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

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

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

  64. 

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

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

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

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

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

  70. 

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

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

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

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

  75. 

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

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

  78.     };

  79. 

  80.     struct BasicOps64

  81.     {

  82.         typedef double Type;

  83.         typedef __m128d ParallelType;

  84.         typedef __m128d IntegerType;

  85.         enum { numParallel = 2 };

  86. 

  87.         // Integer and parallel types are the same for SSE. On neon they have different types

  88.         static forcedinline IntegerType toint (ParallelType v) { return v; }

  89.         static forcedinline ParallelType toflt (IntegerType v) { return v; }

  90. 

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

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

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

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

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

  96. 

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

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

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

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

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

  102. 

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

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

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

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

  107. 

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

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

  110.     };

  111. 

  112.     

  113. 

  114.     #define JUCE_BEGIN_VEC_OP \

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

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

  117.         { \

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

  119. 

  120.     #define JUCE_FINISH_VEC_OP(normalOp) \

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

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

  123.         } \

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

  125. 

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

  127.         JUCE_BEGIN_VEC_OP \

  128.         setupOp \

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

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

  131.         JUCE_FINISH_VEC_OP (normalOp)

  132. 

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

  134.         JUCE_BEGIN_VEC_OP \

  135.         setupOp \

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

  137.         { \

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

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

  140.         }\

  141.         else \

  142.         { \

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

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

  145.         } \

  146.         JUCE_FINISH_VEC_OP (normalOp)

  147. 

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

  149.         JUCE_BEGIN_VEC_OP \

  150.         setupOp \

  151.         { \

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

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

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

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

  156.         } \

  157.         JUCE_FINISH_VEC_OP (normalOp)

  158. 

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

  160.         JUCE_BEGIN_VEC_OP \

  161.         setupOp \

  162.         { \

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

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

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

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

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

  168.         } \

  169.         JUCE_FINISH_VEC_OP (normalOp)

  170. 

  171. 

  172.     //==============================================================================

  173.    #elif JUCE_USE_ARM_NEON

  174. 

  175.     struct BasicOps32

  176.     {

  177.         typedef float Type;

  178.         typedef float32x4_t ParallelType;

  179.         typedef uint32x4 IntegerType;

  180.         enum { numParallel = 4 };

  181. 

  182.         static forcedinline IntegerType toint (ParallelType v) { union { ParallelType f; IntegerType i; } u; u.f = v; return u.i; }

  183.         static forcedinline ParallelType toflt (IntegerType v) { union { ParallelType f; IntegerType i; } u; u.i = v; return u.f; }

  184. 

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

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

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

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

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

  190. 

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

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

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

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

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

  196. 

  197.         static forcedinline ParallelType bit_and (ParallelType a, ParallelType b) noexcept  {  return toflt (vandq_u32 (toint (a), toint (b))); }

  198.         static forcedinline ParallelType bit_not (ParallelType a, ParallelType b) noexcept  {  return toflt (vbicq_u32 (toint (a), toint (b))); }

  199.         static forcedinline ParallelType bit_or  (ParallelType a, ParallelType b) noexcept  {  return toflt (vorrq_u32 (toint (a), toint (b))); }

  200.         static forcedinline ParallelType bit_xor (ParallelType a, ParallelType b) noexcept  {  return toflt (veorq_u32 (toint (a), toint (b))); }

  201. 

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

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

  204.     };

  205. 

  206.     struct BasicOps64

  207.     {

  208.         typedef double Type;

  209.         typedef double ParallelType;

  210.         typedef uint64 IntegerType;

  211.         enum { numParallel = 1 };

  212. 

  213.         static forcedinline IntegerType toint (ParallelType v) { union { ParallelType f; IntegerType i; } u; u.f = v; return u.i; }

  214.         static forcedinline ParallelType toflt (IntegerType v) { union { ParallelType f; IntegerType i; } u; u.i = v; return u.f; }

  215. 

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

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

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

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

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

  221. 

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

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

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

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

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

  227. 

  228.         static forcedinline ParallelType bit_and (ParallelType a, ParallelType b) noexcept  {  return toflt (toint (a) & toint (b)); }

  229.         static forcedinline ParallelType bit_not (ParallelType a, ParallelType b) noexcept  {  return toflt ((~toint (a)) & toint (b)); }

  230.         static forcedinline ParallelType bit_or  (ParallelType a, ParallelType b) noexcept  {  return toflt (toint (a) | toint (b)); }

  231.         static forcedinline ParallelType bit_xor (ParallelType a, ParallelType b) noexcept  {  return toflt (toint (a) ^ toint (b)); }

  232. 

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

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

  235.     };

  236. 

  237.     #define JUCE_BEGIN_VEC_OP \

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

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

  240.         { \

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

  242. 

  243.     #define JUCE_FINISH_VEC_OP(normalOp) \

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

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

  246.         } \

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

  248. 

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

  250.         JUCE_BEGIN_VEC_OP \

  251.         setupOp \

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

  253.         JUCE_FINISH_VEC_OP (normalOp)

  254. 

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

  256.         JUCE_BEGIN_VEC_OP \

  257.         setupOp \

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

  259.         JUCE_FINISH_VEC_OP (normalOp)

  260. 

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

  262.         JUCE_BEGIN_VEC_OP \

  263.         setupOp \

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

  265.         JUCE_FINISH_VEC_OP (normalOp)

  266. 

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

  268.         JUCE_BEGIN_VEC_OP \

  269.         setupOp \

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

  271.         JUCE_FINISH_VEC_OP (normalOp)

  272. 

  273. 

  274.     //==============================================================================

  275.    #else

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

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

  278. 

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

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

  281. 

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

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

  284. 

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

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

  287. 

  288.    #endif

  289. 

  290.     //==============================================================================

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

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

  293.         { \

  294.             locals (srcLoad, dstLoad); \

  295.             dstStore (dest, vecOp); \

  296.             increment; \

  297.         }

  298. 

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

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

  301.         { \

  302.             locals (src1Load, src2Load); \

  303.             dstStore (dest, vecOp); \

  304.             increment; \

  305.         }

  306. 

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

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

  309.         { \

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

  311.             dstStore (dest, vecOp); \

  312.             increment; \

  313.         }

  314. 

  315.     #define JUCE_LOAD_NONE(srcLoad, dstLoad)

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

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

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

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

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

  321. 

  322.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

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

  325. 

  326.     template <typename Mode>

  327.     struct MinMax

  328.     {

  329.         typedef typename Mode::Type Type;

  330.         typedef typename Mode::ParallelType ParallelType;

  331. 

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

  333.         {

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

  335. 

  336.            #if JUCE_USE_SSE_INTRINSICS

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

  338.            #else

  339.             if (numLongOps > 1)

  340.            #endif

  341.             {

  342.                 ParallelType val;

  343. 

  344.                #if ! JUCE_USE_ARM_NEON

  345.                 if (isAligned (src))

  346.                 {

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

  348. 

  349.                     if (isMinimum)

  350.                     {

  351.                         while (--numLongOps > 0)

  352.                         {

  353.                             src += Mode::numParallel;

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

  355.                         }

  356.                     }

  357.                     else

  358.                     {

  359.                         while (--numLongOps > 0)

  360.                         {

  361.                             src += Mode::numParallel;

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

  363.                         }

  364.                     }

  365.                 }

  366.                 else

  367.                #endif

  368.                 {

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

  370. 

  371.                     if (isMinimum)

  372.                     {

  373.                         while (--numLongOps > 0)

  374.                         {

  375.                             src += Mode::numParallel;

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

  377.                         }

  378.                     }

  379.                     else

  380.                     {

  381.                         while (--numLongOps > 0)

  382.                         {

  383.                             src += Mode::numParallel;

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

  385.                         }

  386.                     }

  387.                 }

  388. 

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

  390.                                         : Mode::max (val);

  391. 

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

  393.                 src += Mode::numParallel;

  394. 

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

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

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

  398. 

  399.                 return result;

  400.             }

  401. 

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

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

  404.         }

  405. 

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

  407.         {

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

  409. 

  410.            #if JUCE_USE_SSE_INTRINSICS

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

  412.            #else

  413.             if (numLongOps > 1)

  414.            #endif

  415.             {

  416.                 ParallelType mn, mx;

  417. 

  418.                #if ! JUCE_USE_ARM_NEON

  419.                 if (isAligned (src))

  420.                 {

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

  422.                     mx = mn;

  423. 

  424.                     while (--numLongOps > 0)

  425.                     {

  426.                         src += Mode::numParallel;

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

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

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

  430.                     }

  431.                 }

  432.                 else

  433.                #endif

  434.                 {

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

  436.                     mx = mn;

  437. 

  438.                     while (--numLongOps > 0)

  439.                     {

  440.                         src += Mode::numParallel;

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

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

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

  444.                     }

  445.                 }

  446. 

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

  448.                                     Mode::max (mx));

  449. 

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

  451.                 src += Mode::numParallel;

  452. 

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

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

  455. 

  456.                 return result;

  457.             }

  458. 

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

  460.         }

  461.     };

  462.    #endif

  463. }

  464. 

  465. //==============================================================================

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

  467. {

  468.    #if JUCE_USE_VDSP_FRAMEWORK

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

  470.    #else

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

  472.    #endif

  473. }

  474. 

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

  476. {

  477.    #if JUCE_USE_VDSP_FRAMEWORK

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

  479.    #else

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

  481.    #endif

  482. }

  483. 

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

  485. {

  486.    #if JUCE_USE_VDSP_FRAMEWORK

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

  488.    #else

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

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

  491.    #endif

  492. }

  493. 

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

  495. {

  496.    #if JUCE_USE_VDSP_FRAMEWORK

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

  498.    #else

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

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

  501.    #endif

  502. }

  503. 

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

  505. {

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

  507. }

  508. 

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

  510. {

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

  512. }

  513. 

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

  515. {

  516.    #if JUCE_USE_VDSP_FRAMEWORK

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

  518.    #else

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

  520.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  522.    #endif

  523. }

  524. 

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

  526. {

  527.    #if JUCE_USE_VDSP_FRAMEWORK

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

  529.    #else

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

  531.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  533.    #endif

  534. }

  535. 

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

  537. {

  538.    #if JUCE_USE_VDSP_FRAMEWORK

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

  540.    #else

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

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

  543.    #endif

  544. }

  545. 

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

  547. {

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

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

  550. }

  551. 

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

  553. {

  554.    #if JUCE_USE_VDSP_FRAMEWORK

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

  556.    #else

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

  558.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  560.    #endif

  561. }

  562. 

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

  564. {

  565.    #if JUCE_USE_VDSP_FRAMEWORK

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

  567.    #else

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

  569.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  571.    #endif

  572. }

  573. 

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

  575. {

  576.    #if JUCE_USE_VDSP_FRAMEWORK

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

  578.    #else

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

  580.    #endif

  581. }

  582. 

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

  584. {

  585.    #if JUCE_USE_VDSP_FRAMEWORK

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

  587.    #else

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

  589.    #endif

  590. }

  591. 

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

  593. {

  594.    #if JUCE_USE_VDSP_FRAMEWORK

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

  596.    #else

  597.     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, )

  598.    #endif

  599. }

  600. 

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

  602. {

  603.    #if JUCE_USE_VDSP_FRAMEWORK

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

  605.    #else

  606.     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, )

  607.    #endif

  608. }

  609. 

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

  611. {

  612.    #if JUCE_USE_VDSP_FRAMEWORK

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

  614.    #else

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

  616.    #endif

  617. }

  618. 

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

  620. {

  621.    #if JUCE_USE_VDSP_FRAMEWORK

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

  623.    #else

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

  625.    #endif

  626. }

  627. 

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

  629. {

  630.    #if JUCE_USE_VDSP_FRAMEWORK

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

  632.    #else

  633.     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, )

  634.    #endif

  635. }

  636. 

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

  638. {

  639.    #if JUCE_USE_VDSP_FRAMEWORK

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

  641.    #else

  642.     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, )

  643.    #endif

  644. }

  645. 

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

  647. {

  648.    #if JUCE_USE_VDSP_FRAMEWORK

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

  650.    #else

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

  652.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  654.    #endif

  655. }

  656. 

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

  658. {

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

  660.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  662. }

  663. 

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

  665. {

  666.    #if JUCE_USE_VDSP_FRAMEWORK

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

  668.    #else

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

  670.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  671.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  672.    #endif

  673. }

  674. 

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

  676. {

  677.    #if JUCE_USE_VDSP_FRAMEWORK

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

  679.    #else

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

  681.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  682.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  683.    #endif

  684. }

  685. 

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

  687. {

  688.    #if JUCE_USE_VDSP_FRAMEWORK

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

  690.    #else

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

  692.    #endif

  693. }

  694. 

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

  696. {

  697.    #if JUCE_USE_VDSP_FRAMEWORK

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

  699.    #else

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

  701.    #endif

  702. }

  703. 

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

  705. {

  706.    #if JUCE_USE_VDSP_FRAMEWORK

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

  708.    #else

  709.     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, )

  710.    #endif

  711. }

  712. 

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

  714. {

  715.    #if JUCE_USE_VDSP_FRAMEWORK

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

  717.    #else

  718.     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, )

  719.    #endif

  720. }

  721. 

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

  723. {

  724.    #if JUCE_USE_VDSP_FRAMEWORK

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

  726.    #else

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

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

  729.    #endif

  730. }

  731. 

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

  733. {

  734.    #if JUCE_USE_VDSP_FRAMEWORK

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

  736.    #else

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

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

  739.    #endif

  740. }

  741. 

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

  743. {

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

  745.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  747. }

  748. 

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

  750. {

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

  752.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  754. }

  755. 

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

  757. {

  758.    #if JUCE_USE_VDSP_FRAMEWORK

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

  760.    #else

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

  762.    #endif

  763. }

  764. 

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

  766. {

  767.    #if JUCE_USE_VDSP_FRAMEWORK

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

  769.    #else

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

  771.    #endif

  772. }

  773. 

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

  775. {

  776.    #if JUCE_USE_VDSP_FRAMEWORK

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

  778.    #else

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

  780.     signMask.i = 0x7fffffffUL;

  781.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = fabsf (src[i]), Mode::bit_and (s, mask),

  782.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST, 

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

  784.    #endif

  785. }

  786. 

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

  788. {

  789.    #if JUCE_USE_VDSP_FRAMEWORK

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

  791.    #else

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

  793.     signMask.i = 0x7fffffffffffffffULL;

  794. 

  795.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = fabs (src[i]), Mode::bit_and (s, mask),

  796.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST, 

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

  798.    #endif

  799. }

  800. 

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

  802. {

  803.    #if JUCE_USE_ARM_NEON

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

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

  806.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST, )

  807.    #else

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

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

  810.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST,

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

  812.    #endif

  813. }

  814. 

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

  816. {

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

  818.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  820. }

  821. 

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

  823. {

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

  825.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  827. }

  828. 

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

  830. {

  831.    #if JUCE_USE_VDSP_FRAMEWORK

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

  833.    #else

  834.     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, )

  835.    #endif

  836. }

  837. 

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

  839. {

  840.    #if JUCE_USE_VDSP_FRAMEWORK

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

  842.    #else

  843.     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, )

  844.    #endif

  845. }

  846. 

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

  848. {

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

  850.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  852. }

  853. 

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

  855. {

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

  857.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  859. }

  860. 

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

  862. {

  863.    #if JUCE_USE_VDSP_FRAMEWORK

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

  865.    #else

  866.     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, )

  867.    #endif

  868. }

  869. 

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

  871. {

  872.    #if JUCE_USE_VDSP_FRAMEWORK

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

  874.    #else

  875.     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, )

  876.    #endif

  877. }

  878. 

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

  880. {

  881.     jassert(high >= low);

  882. 

  883.    #if JUCE_USE_VDSP_FRAMEWORK

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

  885.    #else

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

  887.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  889.    #endif

  890. }

  891. 

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

  893. {

  894.     jassert(high >= low);

  895. 

  896.    #if JUCE_USE_VDSP_FRAMEWORK

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

  898.    #else

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

  900.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  902.    #endif

  903. }

  904. 

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

  906. {

  907.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  909.    #else

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

  911.    #endif

  912. }

  913. 

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

  915. {

  916.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  918.    #else

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

  920.    #endif

  921. }

  922. 

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

  924. {

  925.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  927.    #else

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

  929.    #endif

  930. }

  931. 

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

  933. {

  934.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  936.    #else

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

  938.    #endif

  939. }

  940. 

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

  942. {

  943.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  945.    #else

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

  947.    #endif

  948. }

  949. 

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

  951. {

  952.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  954.    #else

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

  956.    #endif

  957. }

  958. 

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

  960. {

  961.    #if JUCE_USE_SSE_INTRINSICS

  962.     if (FloatVectorHelpers::isSSE2Available())

  963.         _MM_SET_FLUSH_ZERO_MODE (shouldEnable ? _MM_FLUSH_ZERO_ON : _MM_FLUSH_ZERO_OFF);

  964.    #endif

  965.     (void) shouldEnable;

  966. }

  967. 

  968. //==============================================================================

  969. //==============================================================================

  970. #if JUCE_UNIT_TESTS

  971. 

  972. class FloatVectorOperationsTests  : public UnitTest

  973. {

  974. public:

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

  976. 

  977.     template <typename ValueType>

  978.     struct TestRunner

  979.     {

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

  981.         {

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

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

  984. 

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

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

  987. 

  988.            #if JUCE_ARM

  989.             ValueType* const data1 = buffer1;

  990.             ValueType* const data2 = buffer2;

  991.             int* const int1 = buffer3;

  992.            #else

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

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

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

  996.            #endif

  997. 

  998.             fillRandomly (random, data1, num);

  999.             fillRandomly (random, data2, num);

  1000. 

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

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

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

  1004. 

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

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

  1007. 

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

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

  1010. 

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

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

  1013. 

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

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

  1016. 

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

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

  1019. 

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

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

  1022. 

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

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

  1025. 

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

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

  1028. 

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

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

  1031. 

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

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

  1034. 

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

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

  1037. 

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

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

  1040. 

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

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

  1043. 

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

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

  1046. 

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

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

  1049. 

  1050.             fillRandomly (random, int1, num);

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

  1052. 

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

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

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

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

  1057.         }

  1058. 

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

  1060.         {

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

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

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

  1064.         }

  1065. 

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

  1067. 

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

  1069.         {

  1070.             while (--num >= 0)

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

  1072.         }

  1073. 

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

  1075.         {

  1076.             while (--num >= 0)

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

  1078.         }

  1079. 

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

  1081.         {

  1082.             while (--num >= 0)

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

  1084.         }

  1085. 

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

  1087.         {

  1088.             while (--num >= 0)

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

  1090.                     return false;

  1091. 

  1092.             return true;

  1093.         }

  1094. 

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

  1096.         {

  1097.             while (--num >= 0)

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

  1099.                     return false;

  1100. 

  1101.             return true;

  1102.         }

  1103. 

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

  1105.         {

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

  1107.         }

  1108.     };

  1109. 

  1110.     void runTest()

  1111.     {

  1112.         beginTest ("FloatVectorOperations");

  1113. 

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

  1115.         {

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

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

  1118.         }

  1119.     }

  1120. };

  1121. 

  1122. static FloatVectorOperationsTests vectorOpTests;

  1123. 

  1124. #endif