basic_dsp 0.7.0

Digital signal processing based on real or complex vectors in time or frequency domain. Vectors come with basic arithmetic, convolution, Fourier transformation and interpolation operations. The vectors are optimized for sizes of a couple of thousand elements or more. The same operations are provdided for matrices. For complete matrix algebra this lib is intended to be used in combination with other matrix libs. Please refer to the documentation for more information about this.
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()