APC_Australia_Issue_442_June_2017

of values that represent a single
sinewave cycle and then clocks those
samples through a digital-to-analog
converter (DAC) at a particular rate,
the clock rate determining the output
sinewave frequency. For example, if
you have one complete sinewave cycle
stored as 1,000 digital samples and
play those samples through a DAC at
the rate of 1,000 samples per second
(1,000Hz), it’d take one second to
output that complete cycle, so the
output frequency of that sinewave
would be one cycle per second or 1Hz.
But if we played out those 1,000
samples at the rate of 1MHz
(1,000,000Hz), it would take only one
millisecond to play the stored cycle,
giving an output frequency of 1/0.001 =
1,000Hz. Now I don’t want to have to
calculate the sinewave value table for
all 1,000 samples by hand, so we’ll get
Python to calculate it instead.
Go the source code zip file again and
this time, load up ‘dds.py’. What we
need in this example is to divide a full
sinewave into 1,000 discrete values.
If you remember back to school maths,
a full sinewave cycle occurs over a
360-degree range, so if we divide that
360-degrees into 1,000 steps and store
away the sine value of each one in
turn, we’ll have our DDS value table.
In fact, our dds.py source code goes
a step further by allowing you to enter
the number of samples you require
and generating a value table based on
that sample count, printing the values
to the console. If you copy and paste
the table values into Excel, you can
create a simple line chart showing
Replicate the same
random-number
sequence by using
random.seed().
Python needs help to
determine equality
of decimal numbers.
the sinewave the table generates —
we’ve done this over 6, 12, 18, 24, 30
and 36 samples and as you might
expect, the more samples you create,
the greater the sinewave accuracy
(the smoother it looks).
FREQUENCY RESPONSE
One of the more basic things you learn
in electronics is how to make a circuit
element called a ‘filter’ using just a
resistor and a capacitor — connected
one way, the circuit allows highpitched
frequencies to pass and
progressively blocks lower
frequencies; connected the other way,
it’s ‘vice-versa’. Either way, there’s a
simple mathematical formula
governing how the basic resistorcapacitor
or ‘RC’ filter works:
3dB cutoff-frequency =
1 / (2 x pi x R x C)
where ‘pi’ is 3.1415..., ‘R’ is the
resistor value in ohms and ‘C’ is
the value of capacitance in farads.
The cutoff point is the frequency
at which the signal amplitude drops
by 3dB from its peak (beyond the 3dB
point, it falls away at the rate of 6dB
per octave).
Load up ‘filter.py’ from the source
code zip and you’ll find a simple 3dB
frequency calculator that uses the
math.pi constant. Python has a
number of math module constants
including Euler’s constant ‘e’ (math.e,
2.718...) and math.tau or pi*2.
To make the app easier to use,
we’ve set the input required to
kiloohms (kΩ) and microfarads (uF),
which are much common units
(at least for audio-frequency work)
than standard ‘ohms’ and ‘farads’.
RANDOM NUMBERS
Random numbers are a vital part of
most computer games — they create
the ‘randomness’ in the action you
need for a game not to become too
predictable. They’re also important
to computer security, but you need
to understand how they work in
Python, especially their limitations.
Python’s ‘random’ module is
separate from the math module and
uses a random number generation
algorithm called the ‘Mersenne
Twister’ to create floating-point
random numbers between 0.0 and 1.0.
However, they’re not strictly ‘random’
— the Mersenne Twister algorithm
will eventually begin repeating
itself, although not until after
2^19,937 iterations. Even so, that
makes the Python ‘random’ module
a ‘no-go’ for security applications.
Here, Python recommends you use
the ‘secrets’ module instead.
But one particularly useful feature
with the random module is the ability
to seed the random number
progression, enabling you to create
a repeatable random number series,
useful in debugging and data mining.
For example, run the code:
random.seed(4)
print(random.random())
print(random.random())
print(random.random())
And then run it again. Note the two
sets of random numbers generated
— they should be exactly the same.
If you don’t start random() with a
seed, Python will use the current
time as a seed instead, ensuring the
random number stream won’t repeat
for some time.
The other thing that random() does
is produce pseudo-random numbers
that are of ‘uniform distribution’ —
that means any number between 0.0
and 1.0 is equally likely to be chosen.
But there are many other
distribution ‘shapes’ you can
generate, including triangular,
betavariate, expovariate and
Gaussian, all useful for statistical
applications.
GIVE IT A GO
Whether it’s in science, technology
or engineering, mathematics really
is a fundamental part of life — and
with Python’s collection of mathsbased
modules, you can quickly
incorporate all sorts of mathematical
functions into your apps.
www.apcmag.com 109