The issue here is to properly translate mathematical equation outputs to understandable audio samples.
There are two main types of mathematical systems here : discrete systems and continuous systems.

- The discrete systems are of the form U(n)=U(n+1), and they generate a series of number.
- The continuous systems are of the form X'(t)=f(X(t)), and they genereate a continuous flow of values.

From a digital audio point of view, it means that :
- Each number generated by a discrete system will be considered as a sample value
- The continuous systems have to be sampled just like analog audio is sampled

And it means that the following issues will arise :
- If a discrete system output is periodic, period 2, the audible result will be at SampleFrequency/2. even at 11kHz, this is quite high.
Thus this output will have to be properly transposed and/or resampled.
- When sampling a continous system output, we have to be careful to choose a sufficient sample freq, which hopefully gets most of the signal spectral range if not all

The differential equation is solved in Maple using the dsolve function.
Since in dsolve, it's possible to choose what would be called Sampling Frequency in the audio field, a few tests are made to get a proper sampled signal.

Dsolve's output sonsists in an array which is exported to a text file using the ExportVector command.
At this point, there are one or several text files, one for X(t), one for Y(t) and one for Z(t) if applicable, each one of those looking like that :

-.6313039889
1.089830169
-.5144845056
1.154694367
-.6224453262
1.050224676
-.4208857425
1.231873512
-.7807111680
.8451451065
etc.

This file is then imported into PureData using the "array read file.txt" function which considers each line to be an unquantized audio file sample value.
This command quantizes the sample value to the usual 16bit depth.

Then PureData re exports the result to a .wav audio file using the soundfiler command.
Afterwards, the samples are "cleaned" : DC offset removal and normalization to -6dB FS.

A procedure is written in Maple that generates each consecutive value.
The result array is exported to a text file using the ExportVector command, as it was done for continuous systems.

At this point, there are one or several text files, one for X(n) or U(n), one for Y(n) and one for Z(n) if applicable.

The consecutive values of U(n) are obtained using a Pure Data patch.
The use of a Pure Data patch, instead of a math software, is justified in this case by possibilites of real time synthesis.

- Real tine aspect :
One can listen to the system real time using the tabosc~4 object.
It gives good result, with a few issues - how the transposition / resampling is made, click problems when the array is looping etc.

- Non real time aspect :
To get clean audio files which can be worked on later.
The values are stored in an array using the same tabosc~4, then written to a file using the soundfiler object.

Whatever the method that was used, we have now a text file full of consecutive numbers.
But what we've got here is not a sampled signal : it's just a series of numbers which are not really a signal yet.

For instance, here is the output of a simple periodic system, read as an audio signal :

It doesn't show, but this signal is really a sinusoid sampled at precisely two times its frequency.

If we resample this signal to 16 times this sampling frequency, the waveform becomes :

The same result can be obtained by transposing the original signal three octaves lower and keeping the same sampling frequency.
This is what is done here, using Peak's pitching function, without its time correction ability on - this process is pretty precise and will do the job quite properly.

Here is how it looks like when this is done on a chaotic signal :

turns to

... which is an audible audio signal.