summaryrefslogtreecommitdiff
path: root/lpf.awk
blob: 814020f7dd337e2ed63c924e43d6f71b47018f6c (plain) (blame)
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
114
115
116
117
118
119
120
121
122
123
124
125
#!/usr/bin/awk -f

### lpf.awk
# Low Pass Filter with Hardcoded FIR Window

BEGIN {
    OFS = FS
    sign = "[+-]?"
    decimal = "[0-9]+[.]?[0-9]*"
    fraction = "[.][0-9]*"
    exponent = "([Ee]" sign "[0-9]+)?"
    number = "^" sign "(" decimal "|" fraction ")" exponent "$"

    #H = ARGV[1]
    #H = 1.0
    #H = "1.00   1.00    1.00"   # rect
    #H = "0.25   0.50    0.25"   # von Hann
    H = "0.23   0.54    0.23"   # Hamming
    window_size = split(H, H_arr, "[ ]*")
}

NR == 1 {
    for (y=1; y<=NF; y++)
        ($y ~ number) ? header[y] = "col" y : header[y] = $y
}

NF > 0 {
    if (NF > nf_max)
        nf_max = NF

    input_size = window_size 
    output_size = (input_size + window_size - 1)

    ### columns
    for (y=1; y<=nf_max; y++) {
        if ($y == header[y])
            printf(header[y] OFS header[y] "_lpf")
        if ($y ~ number) {
            count[y]++

            # rotate input buffer
            for (n=1; n<=input_size; n++) {
                X_arr[y,n] = X_arr[y,n+1]
            }
            X_arr[y,input_size] = $y

            Y[y] = 0
            for (n=1; n<=window_size; n++) {
                for (m=1; m<=input_size; m++) {
                    if (n <= window_size) {
                        Y[y] += H_arr[n-m+1]*X_arr[y,m]
                        continue
                    }
                    if ((n > window_size) && (n <= input_size)) {
                        Y[y] += H_arr[n-m+1]*X_arr[y,m]
                        continue
                    }
                    if ((n > window_size) && (n > input_size)) {
                        Y[y] += H_arr[n-m+1]*X_arr[y,m]
                        continue
                    }
                    else {
                        Y[y] += 0
                        continue
                    }
                }
            }
            printf(X_arr[y,input_size] OFS Y[y])
        }

        if (y < nf_max)
            printf(OFS)
        else
            printf(ORS)
        
    }



}

END {
    ### rows
    for (x=1; x<=window_size; x++) {
        ### columns
        for (y=1; y<=nf_max; y++) {
            # rotate input buffer
            for (n=1; n<=input_size; n++) {
                X_arr[y,n] = X_arr[y,n+1]
                #print X_arr[y,n]
            }
            #delete X_arr[y,input_size]
            #input_size = length(X_arr)
            #print length(X_arr)
            
            Y[y] = 0
            for (n=1; n<=window_size; n++) {
                for (m=1; m<=input_size; m++) {
                    if (n <= window_size) {
                        Y[y] += H_arr[n-m+1]*X_arr[y,m]
                        continue
                    }
                    if ((n > window_size) && (n <= input_size)) {
                        Y[y] += H_arr[n-m+1]*X_arr[y,m]
                        continue
                    }
                    if ((n > window_size) && (n > input_size)) {
                        Y[y] += H_arr[n-m+1]*X_arr[y,m]
                        continue
                    }
                    else {
                        Y[y] += 0
                        continue
                    }
                }
            }
            printf(X_arr[y,input_size] OFS Y[y])
            if (y < nf_max)
                printf(OFS)
            else
                printf(ORS)
            X_arr[input_size] = 0 
        }
    }
}