Wednesday, 24 April 2019

Denormalized Floating Point Numbers Issues

Back in 2013 I wrote a blog post entitled "DSP Tech Brief : Some Notes On Implementing DSP Algorithms - C or Assembly, Fixed or Floating Point" :
Since I wrote that first post I've often thought about writing an update to discuss denormalized floating point numbers. I never got around to it but I recently saw a post that explains the issue perfectly.

Before I get to the specific blog post, a bit of DSP history might help.

Back in the very earliest days of floating point DSPs the silicon manufacturers had the choice of supporting IEEE floating point numbers or not. Supporting IEEE standard floating point numbers sounds like the logical choice however the silicon required to support denormalized numbers without increasing processing time for floating point operations (like general purpose CPUs do) meant that the cost (i.e. number of transistors) of supporting IEEE floating point numbers was far higher than not supporting the standard. Understanding denormalized numbers was key to writing code that could be portable between DSPs that supported them and those that didn't.

Now-a-days most DSPs support IEEE floating point numbers with no run-time overhead for handling denormalized numbers however when the same code is run on a general purpose CPU then the issue of denormalized number support needs to be taken very seriously, to avoid the code becoming very slow.

Now to the excellent summary of the issue of denormalized floating point numbers by Nigel Redmon at EarLevel Engineering :
    The main aricle is :
    And there are some additional useful caveats here :
The best part about Nigel's main article is that it gives some great suggestions about how to avoid these problems.

Further References

Wednesday, 9 January 2019

The Next Round Of The University Of Oxford, UK Digital Signal Processing Courses Take Place In June 2019

As part of the University Of Oxford Summer Engineering Program for Industry, the Digital Signal Processing courses are returning in June 2019, for the 27th year.
The courses are presented by experts from industry for Engineers in industry and over the last 27 years has trained many hundreds of Engineers, from all areas of Science and Engineering.

Here is a summary of the two courses.

Digital Signal Processing (Theory and Application) - Monday 3rd to Wednesday 5th June 2019
This course provides a good understanding of DSP principles and their implementation and equips the delegate to put the ideas into practice and/or to tackle more advanced aspects of DSP. 'Hands-on' laboratory sessions are interspersed with the lectures to illustrate the taught material and allow you to pursue your own areas of interest in DSP. The hands-on sessions use specially written software running on PCs.

Subjects include :

Theoretical Foundations
Digital Filtering
Fourier Transforms And Frequency Domain Processing
DSP Hardware And Programming
ASIC Implementation
Typical DSP Applications

Digital Signal Processing Implementation (algorithms to optimization) - Thursday 6th June 2019

A one-day supplement to the Digital Signal Processing course that takes the theory and translates it into practice.
The course will include a mixed lecture and demonstration format and has been written to be independent of target processor architecture.
The course will show how to take common DSP algorithms and map them onto common processor architectures. It will also give a guide line for how to choose a DSP device, in particular how to choose and use the correct data word length for any application.

Attendee Feedback From Previous Courses :

It was informative, enjoyable and stimulating
Excellent content, very lively thanks to the 2 excellent presenters - Anonymous
A very good introduction to DSP theory
Excellent lecturers! Really useful information and very understandable
Great mix of theory and practice
The lecturers gave a detailed and excellent explanation of the fundamental topics of DSP with real world engineering practice.
This session closes the gap and clears up much confusion between classroom DSP theories and actual DSP implementation.
Very good session, with in-depth discussion on the math and background.

These courses will be held at the University of Oxford, UK

If you have found this solution useful then please do hit the Google (+1) button so that others may be able to find it as well.

Evaluate The Numerix-DSP Libraries :

Tuesday, 2 October 2018

Controlling Tuya (Smart Life) Devices from IFTTT

I have a number of Tuya (Smart Life) lightbulbs and while these are integrated seamlessly with Amazon Voice Services and Google Home, I would also like to be able to control remotely, via Python and also directly by voice from my XMOS VocalFusion™ Stereo Dev Kit (
I looked into the Tuya API ( and decided that it would be much easier to control the lights via IFTTT.

Here is a step-by-step guide.

First we need to enable Webhooks, to allow us to trigger the event via a URL. To do so, search for “Webhook” here :

Click on "Webhooks" and activate it.

This will give you a URL that looks like :
Where xxxxxxxxxxxxxxxxxx is your key, which we will use later.

To create a private Applets go to : - note the username is your IFTTT username.

Click New Applet and fill out the fields :

Note for triggering events using URLs I find it easier to ensure there are no spaces in the trigger name e.g. “Turn_On_Light”.
Scroll Down to Action and enter the details :

Enter a Title and Description. I just used “Turn On Light”

Click Save.
Click “Enable On IFTTT”
Turn The Applet On.

You can also create an Applet to turn off the Light. Or to make it easy, just go to the Applet Preview Page and hit “Copy” for the above Applet.
Modify the details of the new Applet and click Save.

You can view your private Applets here :

To test your Applet go to here :

Enter then name of your Applet “Turn_On_Light” in {event} and click “Test It”.

Now our Applets are setup and tested we only need the URLs for turning on and off the light, these are :

To trigger the events, just open up the above URLs in a browser and you should be able to remotely control the light.

Alternatively, using Python requests you can do :

import requests"")

Thursday, 27 September 2018

Calling The SigLib Digital Signal Processing Library From Python

I recently wrote a blog post about

Calling The SigLib Digital Signal Processing Library From Julia

and it made me reflect on my main development environment for prototyping DSP code in Python. I've used SWIG ( as an interface for many years and like its portability but I wondered about how to access a shared library from Python directly so did a bit of investigation and found the ctypes API to be very light weight and very easy to use.

To run SigLib (or any other shared library) from Python is very easy using ctypes.

For SigLib, copy the following code into a file "" :

import ctypes
import numpy as np
import platform as _platform

A = np.array([3.4, 1.8, -2.8, 6.4])
B = np.zeros((A.size), dtype=np.double)

if _platform.system() == "Linux":
   lib = ctypes.cdll.LoadLibrary('./')
elif _platform.system() == "Darwin":
   lib = ctypes.cdll.LoadLibrary('./siglib.dylib')
elif _platform.system() == "Windows":
    if _platform.machine().endswith('64'):
        lib = ctypes.cdll.LoadLibrary('.\siglib64.dll')
        lib = ctypes.cdll.LoadLibrary('.\siglib.dll')

SDA_AbsMax = lib.SDA_AbsMax
SDA_AbsMax.restype = ctypes.c_double
absMax = SDA_AbsMax(ctypes.c_void_p(, ctypes.c_int(A.size))

SDA_SortMinToMax = lib.SDA_SortMinToMax
SDA_SortMinToMax(ctypes.c_void_p(, ctypes.c_void_p(, ctypes.c_int(A.size))

print ('absMax: ', absMax)
print ('B: %s' % B)

Now copy the SigLib shared object (.so, .dll or .dylib) file from /siglib/lib to the current working directory and run :


For further information about using SigLib, Python and SWIG, please see this blog post :

How To Access A Windows Library From Python, Using SWIG

To download the evaluation version of the Numerix-DSP Libraries :

Tuesday, 25 September 2018

Calling The SigLib Digital Signal Processing Library From Julia

SigLib DSP functions can be called from many languages, such as Python, Java, C#, Perl etc., using the SWIG API.

I've been tracking Julia for a while however V1.0 of Julia was released recently so I thought I would evaluate some of its cool features for DSP prototyping.

Integrating SigLib with Julia was unbelievably easy using the ccall API. If only other languages contained a similarly simple API ;-)

To run SigLib (or any other shared library) from Julia is very easy using ccall.

For SigLib, copy the following code into a file "juliaSigLib.jl" :

A = [3.4, 1.8, -2.8, 6.4]
B = Array{Float64,1}(undef, length(A))

absMax = ccall((:SDA_AbsMax, "siglib"), Float64, (Ptr{Cdouble},Cint), A, length(A))
println("absMax: ", absMax)

ccall((:SDA_SortMinToMax, "siglib"), Cvoid, (Ptr{Cdouble},Ptr{Cdouble},Cint), A, B, length(A))
println("B: ", B)

Now copy the appropriate shared library to the current working directory where you will run juliaSigLib.jl.

OS Source File Destination File
32 Bit Linux siglib/lib/linux/
64 Bit Linux siglib/lib/linux_64/
Raspberry Pi Linux siglib/lib/RaspberryPi/
32 Bit Windows siglib\lib\Microsoft\dynamic_library\Release\siglib.dll siglib.dll
64 Bit Windows siglib\lib\Microsoft\dynamic_library_64\Release\siglib64.dll siglib.dll

To execute the script use :

julia juliaSigLib.jl


Reference :

To download the evaluation version of the Numerix-DSP Libraries :

Saturday, 28 July 2018

How To Interpolate The Output Of An FFT To Get Higher Resolution

One common requirement for a frequency analyzer is to maximize the amplitude or frequency estimation estimate for a given sinusoid.

One easy way to do this is to increase the size of the FFT however this comes at the cost of reduced time domain resolution and increased requirement for MIPS and memory.

A low impact solution to increase the resolution of the output is to interpolate the vertex to give a better estimate of the amplitude and frequency of an individual sinusoid.

The overall procedure is shown in the following diagram :

FFT Interpolation Functions

Following the FFT function is a peak detector followed by a peak interpolator.
The interpolation function uses 3 point vertex quadratic interpolation, as shown in the following diagram.

Peak Interpoation

Given that xm is the location of the peak and ym is the magnitude of the peak we can interpolate the peak value efficiently by setting xm-1 == 0, xm == 1, xm+1 == 2, which allows the interpolation to be implemented using the following equations :

a = (ym-1 - ym) * (ym-1 - ym+1)
b = -2 * (ym-1 -ym) + 0.5 * (ym-1 - ym+1)

Interpolated Frequency = -0.5 * b / a
Interpolated Magnitude = ym-1 - 0.25 * b2 / a

To analyze the results, we ran a series of sinusoids through the algorithm and plotted the percentage error. In the following graph we have a normalized sample rate of 1.0 Hz and we are using a 512 point FFT. Plotting the error percentage results between FFT bin 7 (0.013671875 Hz) and FFT bin 9 (0.017578125 Hz).

Interpolation Function Results

We can observe that the maximum gain error percentage = 4.519154% and the maximum frequency error percentage = 0.596755%.

Note, this solution is very accurate when the signal constitutes a single sinusoid or a sinusoid sampled with low noise. However the accuracy will vary with increasing noise an/or adjacent sinusoids - chosing a good windowing function will definitely help with the latter.

Functions to implement the FFT interpoator are included in the SigLib DSP library. To evaluate the Numerix-DSP Libraries :

Friday, 22 June 2018

Really Useful Digital Filter Design Spreadsheet

I have uploaded a Really Useful Digital Filter Design Spreadsheet to my Applications Note section : because it no longer appears on the Music-DSP archive, where I originally found it.

It implements the equations from the excellent RBJ Audio-EQ-Cookbook and has some minor fixes.

I have used this spreadsheet for a lot of audio filter design work and also teaching students. I have tried to track down the original author, to give them the credit they deserve. If anyone knows who wrote this spreadsheet then please do ask them to get in touch.