basic_dsp 0.10.2

Digital signal processing based on real or complex vectors in time or frequency domain.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

from scipy import signal
import numpy
import matplotlib.pyplot as plt
import ctypes
import struct
import time

#
# An example which compares interpolatef, interpolate and numpy resample
#

class VecResult(ctypes.Structure):
    _fields_ = [("resultCode", ctypes.c_int),
                ("result", ctypes.c_void_p)]

lib = ctypes.WinDLL('basic_dsp.dll')

new64Proto = ctypes.WINFUNCTYPE (
    ctypes.c_void_p, # Return type.
    ctypes.c_int,
    ctypes.c_int,
    ctypes.c_double,
    ctypes.c_ulong,
    ctypes.c_double)

new64 = new64Proto (("new64", lib))

getValue64Proto = ctypes.WINFUNCTYPE (
    ctypes.c_double, # Return type.
    ctypes.c_void_p,
    ctypes.c_ulong)

getValue = getValue64Proto (("get_value64", lib))

setValue64Proto = ctypes.WINFUNCTYPE (
    ctypes.c_void_p, # Return type.
    ctypes.c_void_p,
    ctypes.c_ulong,
    ctypes.c_double)

setValue = setValue64Proto (("set_value64", lib))

interpftProto = ctypes.WINFUNCTYPE (
    VecResult, # Return type.
    ctypes.c_void_p,
    ctypes.c_ulong)

interpft = interpftProto (("interpft64", lib))

interpolateProto = ctypes.WINFUNCTYPE (
    VecResult, # Return type.
    ctypes.c_void_p,
    ctypes.c_int,
    ctypes.c_double,
    ctypes.c_ulong,
    ctypes.c_double)

interpolate = interpolateProto (("interpolate64", lib))

interpolatefProto = ctypes.WINFUNCTYPE (
    VecResult, # Return type.
    ctypes.c_void_p,
    ctypes.c_int,
    ctypes.c_double,
    ctypes.c_double,
    ctypes.c_double,
    ctypes.c_ulong)

interpolatef = interpolatefProto (("interpolatef64", lib))

vec = new64(
        ctypes.c_int(0),
        ctypes.c_int(0),
        ctypes.c_double(0.0),
        ctypes.c_ulong(20),
        ctypes.c_double(1.0))

num = 20
x = numpy.linspace(0, 30, num=num, endpoint=False)
y1 = numpy.cos(-x*2/6.0)
y4 = signal.resample(y1, 5 * num)

for i in range(0, num-1):
    setValue(vec, i, y1[i])
vec_res = interpolate(vec, 0, 0, 5 * num, 0.5)
assert(vec_res.resultCode == 0)
vec = vec_res.result

y2 = [0.0] * 5 * num
for i in range(0, 5 * num-1):
    y2[i] = getValue(vec, i)

vec = new64(
        ctypes.c_int(0),
        ctypes.c_int(0),
        ctypes.c_double(0.0),
        ctypes.c_ulong(20),
        ctypes.c_double(1.0))
for i in range(0, num-1):
    setValue(vec, i, y1[i])

vec_res = interpolatef(vec, 0, 0, 5, -0.5, 32)
assert(vec_res.resultCode == 0)
vec = vec_res.result

y3 = [0.0] * 5 * num
for i in range(0, 5 * num - 1):
    y3[i] = getValue(vec, i)

xnew = numpy.linspace(0, 30, 5 * num, endpoint=False)
plt.plot(x, y1, 'go-', xnew, y3, '.-', xnew, y2, '--', xnew, y4, 'ro')
plt.legend(['data', 'interpolatef (0.5 shift)', 'interpolate (0.5 shift)', 'numpy (0.0 shift)'], loc='best')
plt.show()