Some cleaning to the text

Author: christophe0606

content/learning-paths/embedded-and-microcontrollers/cmsisdsp-dev-with-python/_index.md

@@ -1,21 +1,21 @@
 ---
-title: Learn how to get started with CMSIS-DSP using Python
+title: Getting Started with CMSIS-DSP Using Python
 
-minutes_to_complete: 10
+minutes_to_complete: 30
 
 who_is_this_for: Developers writing DSP/AI software
 
 learning_objectives: 
     - Understand how to use the CMSIS-DSP Python package
-    - Understand how the Python implementation maps to the C one
-    - Develop a complex application with CMSIS-DSP
+    - Understand how the Python implementation maps to the C implementation
+    - Develop a complex application using CMSIS-DSP
 
 prerequisites:
     - Some familiarity with DSP programming
     - Some familiarity with Python programming
     - Knowledge of C
     - Some familiarity with CMSIS-DSP
-    - Python installed on your computer
+    - Python installed on your system
 
 author: Christophe Favergeon
 

content/learning-paths/embedded-and-microcontrollers/cmsisdsp-dev-with-python/how-to-1.md

@@ -18,7 +18,7 @@ The CMSIS-DSP Python package is a Python API for CMSIS-DSP. Its goal is to make
 
 For this reason, the Python API is as close as possible to the C one.
 
-Fixed point arithmetic is not often provided by Python packages which generally focus on floating-point operations. The CMSIS-DSP Python package provides the same fixed point arithmetic functions as the C version : Q31, Q15 and Q7. The package is also providing float functions and in the future will also provide half-precision floats like the C API.
+Fixed-point arithmetic is rarely provided by Python packages, which generally focus on floating-point operations. The CMSIS-DSP Python package provides the same fixed-point arithmetic functions as the C version: Q31, Q15 and Q7. The package also provides floating-point functions and will also support half-precision floats in the future, like the C API.
 
-Finally, the CMSIS-DSP Python package is compatible with NumPy and can be used with all other scientific and AI Python packages such as SciPy or PyTorch.
+Finally, the CMSIS-DSP Python package is compatible with NumPy and can be used with all other scientific and AI Python packages such as SciPy and PyTorch.
 

content/learning-paths/embedded-and-microcontrollers/cmsisdsp-dev-with-python/how-to-5.md

@@ -23,7 +23,7 @@ plt.show()
 
 The slices we created are overlapping. By applying a Hanning window function and summing the slices, you can reconstruct the original signal. 
 
-Indeed, summing two Hanning window shifted by half the width of the sample block:
+Indeed, summing two Hanning windows shifted by half the width of the sample block gives:
 ![summed hanning alt-text#center](sumhanning.png "Figure 5. Summed Hanning Window")
 
 As result, if you multiply the overlapping blocks of samples by Hanning windows and sum the result, you can reconstruct the original signal:
@@ -96,27 +96,61 @@ scaling = (energy - self._noise)/energy
 
 (Don’t evaluate this Python code in your Jupyter notebook—it will be run later as part of the full implementation.)
 
-### NoiseSuppressionReference class
+### NoiseSuppression and NoiseSuppressionReference classes
 
 The entire algorithm will be packaged as a Python class.
 The class functions are explained below using Python code that should not be evaluated in the Jupyter notebook.
 
 You should only evaluate the full class definition in the Jupyter notebook—not the code snippets used for explanation.
 
 
-#### NoiseSuppressionReference constructor
+#### NoiseSuppression constructor
 
+`NoiseSuppression` is a shared class used by both the float reference implementation and the Q15 version.
 
+```python
+class NoiseSuppression():
+    def __init__(self,slices):
+            self._windowLength=len(slices[0])
+            self._fftLen,self._fftShift=fft_length(self._windowLength)
+            
+            self._padding_left=(self._fftLen - self._windowLength)//2 
+            self._padding_right=self._fftLen- self._windowLength-self._padding_left
+             
+            self._signal=[]
+            self._slices=slices
+            self._window=None
+```
 
-The constructor:
+The constructor for `NoiseSuppression`:
 - Uses the audio slices as input
-- Computes the VAD signal for the full audio signal
-- Applies the Hanning window to each slice
 - Computes the FFT length that can be used for each slice
 - Computes the padding needed for the FFT
 
 The FFT length must be a power of 2. The slice length is not necessarily a power of 2. The constructor computes the closest usable power of 2. The audio slices are padded with zeros on both sides to match the required FFT length.
 
+#### NoiseSuppressionReference constructor
+
+```python
+class NoiseSuppressionReference(NoiseSuppression):
+    def __init__(self,slices):
+        # In a better version this could be computed from the signal length by taking the
+        # smaller power of two greater than the signal length.
+        NoiseSuppression.__init__(self,slices)
+        
+        # Compute the vad signal
+        self._vad=clean_vad([signal_vad(w) for w in slices])
+        self._noise=np.zeros(self._fftLen)
+        # The Hann window
+        self._window=dsp.arm_hanning_f32(self._windowLength)
+```
+
+The constructor for `NoiseSuppressionReference`:
+- Uses the audio slices as input
+- Call the constructor for `NoiseSuppression`
+- Computes the VAD signal for the full audio signal
+- Compute the Hanning window
+
 
 #### subnoise
 ```python
@@ -218,6 +252,9 @@ def overlap_and_add(self):
 ```
 
 ### The final code for the Python class
+
+You can evaluate this code in your Jupyter notebook.
+
 ```python
 def fft_length(length):
     result=2

content/learning-paths/embedded-and-microcontrollers/cmsisdsp-dev-with-python/how-to-6.md

@@ -370,7 +370,7 @@ If the Python package has been built with Neon acceleration, it will use the new
 
 If this temporary buffer is not provided, the Python package will allocate it automatically. While you can use the same API, this is less efficient.
 
-It is better to detect than the package have been compiled with Neon acceleration, allocate a temporary buffer and use it in the FFT calls.
+It is better to detect whether  the package has been compiled with Neon acceleration, allocate a temporary buffer and use it in the FFT calls. This approach is closer to how the C API must be used.
 
 ```python
 if dsp.has_neon():