diff --git a/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp b/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp
index e4aa2e7fb6..fbe494320c 100644
--- a/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp
+++ b/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp
@@ -1177,245 +1177,245 @@ namespace
 
 //==============================================================================
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::clear (FloatType* dest,
-                                                                                   CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::clear (FloatType* dest,
+                                                                           CountType numValues) noexcept
 {
     FloatVectorHelpers::clear (dest, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::fill (FloatType* dest,
-                                                                                  FloatType valueToFill,
-                                                                                  CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::fill (FloatType* dest,
+                                                                          FloatType valueToFill,
+                                                                          CountType numValues) noexcept
 {
     FloatVectorHelpers::fill (dest, valueToFill, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::copy (FloatType* dest,
-                                                                                  const FloatType* src,
-                                                                                  CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::copy (FloatType* dest,
+                                                                          const FloatType* src,
+                                                                          CountType numValues) noexcept
 {
     memcpy (dest, src, (size_t) numValues * sizeof (FloatType));
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::copyWithMultiply (FloatType* dest,
-                                                                                              const FloatType* src,
-                                                                                              FloatType multiplier,
-                                                                                              CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::copyWithMultiply (FloatType* dest,
+                                                                                      const FloatType* src,
+                                                                                      FloatType multiplier,
+                                                                                      CountType numValues) noexcept
 {
     FloatVectorHelpers::copyWithMultiply (dest, src, multiplier, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::add (FloatType* dest,
-                                                                                 FloatType amountToAdd,
-                                                                                 CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::add (FloatType* dest,
+                                                                         FloatType amountToAdd,
+                                                                         CountType numValues) noexcept
 {
     FloatVectorHelpers::add (dest, amountToAdd, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::add (FloatType* dest,
-                                                                                 const FloatType* src,
-                                                                                 FloatType amount,
-                                                                                 CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::add (FloatType* dest,
+                                                                         const FloatType* src,
+                                                                         FloatType amount,
+                                                                         CountType numValues) noexcept
 {
     FloatVectorHelpers::add (dest, src, amount, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::add (FloatType* dest,
-                                                                                 const FloatType* src,
-                                                                                 CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::add (FloatType* dest,
+                                                                         const FloatType* src,
+                                                                         CountType numValues) noexcept
 {
     FloatVectorHelpers::add (dest, src, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::add (FloatType* dest,
-                                                                                 const FloatType* src1,
-                                                                                 const FloatType* src2,
-                                                                                 CountType num) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::add (FloatType* dest,
+                                                                         const FloatType* src1,
+                                                                         const FloatType* src2,
+                                                                         CountType num) noexcept
 {
     FloatVectorHelpers::add (dest, src1, src2, num);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::subtract (FloatType* dest,
-                                                                                      const FloatType* src,
-                                                                                      CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::subtract (FloatType* dest,
+                                                                              const FloatType* src,
+                                                                              CountType numValues) noexcept
 {
     FloatVectorHelpers::subtract (dest, src, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::subtract (FloatType* dest,
-                                                                                      const FloatType* src1,
-                                                                                      const FloatType* src2,
-                                                                                      CountType num) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::subtract (FloatType* dest,
+                                                                              const FloatType* src1,
+                                                                              const FloatType* src2,
+                                                                              CountType num) noexcept
 {
     FloatVectorHelpers::subtract (dest, src1, src2, num);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::addWithMultiply (FloatType* dest,
-                                                                                             const FloatType* src,
-                                                                                             FloatType multiplier,
-                                                                                             CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::addWithMultiply (FloatType* dest,
+                                                                                     const FloatType* src,
+                                                                                     FloatType multiplier,
+                                                                                     CountType numValues) noexcept
 {
     FloatVectorHelpers::addWithMultiply (dest, src, multiplier, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::addWithMultiply (FloatType* dest,
-                                                                                             const FloatType* src1,
-                                                                                             const FloatType* src2,
-                                                                                             CountType num) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::addWithMultiply (FloatType* dest,
+                                                                                     const FloatType* src1,
+                                                                                     const FloatType* src2,
+                                                                                     CountType num) noexcept
 {
     FloatVectorHelpers::addWithMultiply (dest, src1, src2, num);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::subtractWithMultiply (FloatType* dest,
-                                                                                                  const FloatType* src,
-                                                                                                  FloatType multiplier,
-                                                                                                  CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::subtractWithMultiply (FloatType* dest,
+                                                                                          const FloatType* src,
+                                                                                          FloatType multiplier,
+                                                                                          CountType numValues) noexcept
 {
     FloatVectorHelpers::subtractWithMultiply (dest, src, multiplier, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::subtractWithMultiply (FloatType* dest,
-                                                                                                  const FloatType* src1,
-                                                                                                  const FloatType* src2,
-                                                                                                  CountType num) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::subtractWithMultiply (FloatType* dest,
+                                                                                          const FloatType* src1,
+                                                                                          const FloatType* src2,
+                                                                                          CountType num) noexcept
 {
     FloatVectorHelpers::subtractWithMultiply (dest, src1, src2, num);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::multiply (FloatType* dest,
-                                                                                      const FloatType* src,
-                                                                                      CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::multiply (FloatType* dest,
+                                                                              const FloatType* src,
+                                                                              CountType numValues) noexcept
 {
     FloatVectorHelpers::multiply (dest, src, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::multiply (FloatType* dest,
-                                                                                      const FloatType* src1,
-                                                                                      const FloatType* src2,
-                                                                                      CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::multiply (FloatType* dest,
+                                                                              const FloatType* src1,
+                                                                              const FloatType* src2,
+                                                                              CountType numValues) noexcept
 {
     FloatVectorHelpers::multiply (dest, src1, src2, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::multiply (FloatType* dest,
-                                                                                      FloatType multiplier,
-                                                                                      CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::multiply (FloatType* dest,
+                                                                              FloatType multiplier,
+                                                                              CountType numValues) noexcept
 {
     FloatVectorHelpers::multiply (dest, multiplier, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::multiply (FloatType* dest,
-                                                                                      const FloatType* src,
-                                                                                      FloatType multiplier,
-                                                                                      CountType num) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::multiply (FloatType* dest,
+                                                                              const FloatType* src,
+                                                                              FloatType multiplier,
+                                                                              CountType num) noexcept
 {
     FloatVectorHelpers::multiply (dest, src, multiplier, num);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::negate (FloatType* dest,
-                                                                                    const FloatType* src,
-                                                                                    CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::negate (FloatType* dest,
+                                                                            const FloatType* src,
+                                                                            CountType numValues) noexcept
 {
     FloatVectorHelpers::negate (dest, src, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::abs (FloatType* dest,
-                                                                                 const FloatType* src,
-                                                                                 CountType numValues) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::abs (FloatType* dest,
+                                                                         const FloatType* src,
+                                                                         CountType numValues) noexcept
 {
     FloatVectorHelpers::abs (dest, src, numValues);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::min (FloatType* dest,
-                                                                                 const FloatType* src,
-                                                                                 FloatType comp,
-                                                                                 CountType num) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::min (FloatType* dest,
+                                                                         const FloatType* src,
+                                                                         FloatType comp,
+                                                                         CountType num) noexcept
 {
     FloatVectorHelpers::min (dest, src, comp, num);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::min (FloatType* dest,
-                                                                                 const FloatType* src1,
-                                                                                 const FloatType* src2,
-                                                                                 CountType num) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::min (FloatType* dest,
+                                                                         const FloatType* src1,
+                                                                         const FloatType* src2,
+                                                                         CountType num) noexcept
 {
     FloatVectorHelpers::min (dest, src1, src2, num);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::max (FloatType* dest,
-                                                                                 const FloatType* src,
-                                                                                 FloatType comp,
-                                                                                 CountType num) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::max (FloatType* dest,
+                                                                         const FloatType* src,
+                                                                         FloatType comp,
+                                                                         CountType num) noexcept
 {
     FloatVectorHelpers::max (dest, src, comp, num);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::max (FloatType* dest,
-                                                                                 const FloatType* src1,
-                                                                                 const FloatType* src2,
-                                                                                 CountType num) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::max (FloatType* dest,
+                                                                         const FloatType* src1,
+                                                                         const FloatType* src2,
+                                                                         CountType num) noexcept
 {
     FloatVectorHelpers::max (dest, src1, src2, num);
 }
 
 template <typename FloatType, typename CountType>
-void JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::clip (FloatType* dest,
-                                                                                  const FloatType* src,
-                                                                                  FloatType low,
-                                                                                  FloatType high,
-                                                                                  CountType num) noexcept
+void JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::clip (FloatType* dest,
+                                                                          const FloatType* src,
+                                                                          FloatType low,
+                                                                          FloatType high,
+                                                                          CountType num) noexcept
 {
     FloatVectorHelpers::clip (dest, src, low, high, num);
 }
 
 template <typename FloatType, typename CountType>
-Range<FloatType> JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::findMinAndMax (const FloatType* src,
-                                                                                                       CountType numValues) noexcept
+Range<FloatType> JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::findMinAndMax (const FloatType* src,
+                                                                                               CountType numValues) noexcept
 {
     return FloatVectorHelpers::findMinAndMax (src, numValues);
 }
 
 template <typename FloatType, typename CountType>
-FloatType JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::findMinimum (const FloatType* src,
-                                                                                              CountType numValues) noexcept
+FloatType JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::findMinimum (const FloatType* src,
+                                                                                      CountType numValues) noexcept
 {
     return FloatVectorHelpers::findMinimum (src, numValues);
 }
 
 template <typename FloatType, typename CountType>
-FloatType JUCE_CALLTYPE detail::FloatVectorOperationsBase<FloatType, CountType>::findMaximum (const FloatType* src,
-                                                                                              CountType numValues) noexcept
+FloatType JUCE_CALLTYPE FloatVectorOperationsBase<FloatType, CountType>::findMaximum (const FloatType* src,
+                                                                                      CountType numValues) noexcept
 {
     return FloatVectorHelpers::findMaximum (src, numValues);
 }
 
-template struct detail::FloatVectorOperationsBase<float, int>;
-template struct detail::FloatVectorOperationsBase<float, size_t>;
-template struct detail::FloatVectorOperationsBase<double, int>;
-template struct detail::FloatVectorOperationsBase<double, size_t>;
+template struct FloatVectorOperationsBase<float, int>;
+template struct FloatVectorOperationsBase<float, size_t>;
+template struct FloatVectorOperationsBase<double, int>;
+template struct FloatVectorOperationsBase<double, size_t>;
 
 void JUCE_CALLTYPE FloatVectorOperations::convertFixedToFloat (float* dest, const int* src, float multiplier, size_t num) noexcept
 {
diff --git a/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.h b/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.h
index 2bdcef7a1d..ce6ee0359d 100644
--- a/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.h
+++ b/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.h
@@ -32,10 +32,24 @@ namespace juce
 #endif
 class ScopedNoDenormals;
 
-#if ! DOXYGEN
-namespace detail
-{
+//==============================================================================
+/**
+    A collection of simple vector operations on arrays of floating point numbers,
+    accelerated with SIMD instructions where possible, usually accessed from
+    the FloatVectorOperations class.
+
+    @code
+    float data[64];
+
+    // The following two function calls are equivalent:
+    FloatVectorOperationsBase<float, int>::clear (data, 64);
+    FloatVectorOperations::clear (data, 64);
+    @endcode
+
+    @see FloatVectorOperations
 
+    @tags{Audio}
+*/
 template <typename FloatType, typename CountType>
 struct FloatVectorOperationsBase
 {
@@ -69,6 +83,10 @@ struct FloatVectorOperationsBase
     static FloatType JUCE_CALLTYPE findMaximum (const FloatType* src, CountType numValues) noexcept;
 };
 
+#if ! DOXYGEN
+namespace detail
+{
+
 template <typename...>
 struct NameForwarder;
 
@@ -135,15 +153,18 @@ struct NameForwarder<Head, Tail...> : Head, NameForwarder<Tail...>
 
 //==============================================================================
 /**
-    A collection of simple vector operations on arrays of floats, accelerated with
-    SIMD instructions where possible.
+    A collection of simple vector operations on arrays of floating point numbers,
+    accelerated with SIMD instructions where possible and providing all methods
+    from FloatVectorOperationsBase.
+
+    @see FloatVectorOperationsBase
 
     @tags{Audio}
 */
-class JUCE_API  FloatVectorOperations : public detail::NameForwarder<detail::FloatVectorOperationsBase<float, int>,
-                                                                     detail::FloatVectorOperationsBase<float, size_t>,
-                                                                     detail::FloatVectorOperationsBase<double, int>,
-                                                                     detail::FloatVectorOperationsBase<double, size_t>>
+class JUCE_API  FloatVectorOperations : public detail::NameForwarder<FloatVectorOperationsBase<float, int>,
+                                                                     FloatVectorOperationsBase<float, size_t>,
+                                                                     FloatVectorOperationsBase<double, int>,
+                                                                     FloatVectorOperationsBase<double, size_t>>
 {
 public:
     static void JUCE_CALLTYPE convertFixedToFloat (float* dest, const int* src, float multiplier, int num) noexcept;