4385132063

Build # 4385132063

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #316 from jecisc/divers-cleanings

Run Details

2977 of 2977 new or added lines in 214 files covered. (100.0%)

19725 of 24212 relevant lines covered (81.47%)

2.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.39

/src/Math-FastFourierTransform/PMFastFourierTransform.class.st

"
A FastFourierTransform can be initialized with: 
FastFourierTransform data: anArrayOfNumbersOrComplex
you can look at the data with #data, #realData and #imaginaryData.
#transform calculates the Fourier transform (in place, iow you get the transform again with #data etc) and #inverseTransform does the inverse. 
"
Class {
        #name : #PMFastFourierTransform,
        #superclass : #Object,
        #instVars : [
                'nu',
                'n',
                'sinTable',
                'permTable',
                'data'
        ],
        #category : #'Math-FastFourierTransform'
}

{ #category : #'instance creation' }
PMFastFourierTransform class >> data: anArrayOfNumbersOrComplex [
        ^ self new
                data: anArrayOfNumbersOrComplex;
                yourself
]

{ #category : #accessing }
PMFastFourierTransform >> chop: tolerance [
        "sets numbers smaller than tolerance to zero"

        | r i |
        ^ data := data
                collect:
                        [ :k |
                        r := k real.
                        i := k imaginary.
                        r abs < tolerance
                                ifTrue: [ r := 0 ].
                        i abs < tolerance
                                ifTrue: [ i := 0 ].
                        PMComplexNumber real: r imaginary: i ]
]

{ #category : #accessing }
PMFastFourierTransform >> data [
        ^ data
]

{ #category : #accessing }
PMFastFourierTransform >> data: anArrayOfNumberOrComplex [
        | aSize |
        aSize := anArrayOfNumberOrComplex size.
        aSize < 4
                ifTrue: [ ^ self error: 'dataSize must be at least 4' ].
        aSize isPowerOfTwo
                ifFalse: [ ^ self error: 'dataSize must be a power of two' ].
        data := anArrayOfNumberOrComplex collect: [ :i | i asComplex ] as: Array.
        n = aSize
                ifTrue: [ ^ data ].
        "initialize the rest:"
        n := aSize.
        nu := (aSize log: 2) asInteger.
        self initPermTable.
        self initSinTable.
        ^ data
]

{ #category : #accessing }
PMFastFourierTransform >> imaginaryData [
        ^ data collect: [ :i | i imaginary ]
]

{ #category : #initializing }
PMFastFourierTransform >> initPermTable [
        | r |
        permTable := OrderedCollection new: n // 2.
        2 to: n - 1 do: [ :i |
                r := (i - 1 bitReverse: nu) + 1.
                r > i
                        ifTrue: [ permTable
                                        add: (Array with: i with: r) ] ]
]

{ #category : #initializing }
PMFastFourierTransform >> initSinTable [
        | d |
        d := n // 2.
        sinTable := (0 to: n // 4) collect: [ :i | (Float pi * i / d) sin ]
]

{ #category : #evaluation }
PMFastFourierTransform >> inverseTransform [
        self transformForward: false.
        ^ data
]

{ #category : #private }
PMFastFourierTransform >> multiplier: theta [
        ^ theta < (n // 4)
                ifTrue:
                        [ PMComplexNumber real: (sinTable at: sinTable size - theta) imaginary: (sinTable at: theta + 1) ]
                ifFalse:
                        [ PMComplexNumber
                                real: (sinTable at: theta - (n // 4) + 1) negated
                                imaginary: (sinTable at: n // 2 - theta + 1) ]
]

{ #category : #accessing }
PMFastFourierTransform >> n [
        ^ n
]

{ #category : #accessing }
PMFastFourierTransform >> realData [
        ^ data collect: [ :i | i real ]
]

{ #category : #private }
PMFastFourierTransform >> scaleData [
        | temp |
        temp := n sqrt.
        data := data collect: [ :j | PMComplexNumber real: j real / temp imaginary: j imaginary / temp ]        "minimizes floating point error this way"
]

{ #category : #evaluation }
PMFastFourierTransform >> transform [
        self transformForward: true.
        ^ data
]

{ #category : #private }
PMFastFourierTransform >> transformForward: forward [
        | lev lev1 ip temp temp2 i |
        permTable do: [ :j | data swap: j first with: j second ].
        1 to: nu do:
                [ :level |
                lev := 1 bitShift: level.
                lev1 := lev // 2.
                1 to: lev1 do:
                        [ :j |
                        temp := self multiplier: (j - 1) * (n // lev).
                        forward
                                ifFalse: [ temp := temp complexConjugate ].
                        i := j.
                        [ i <= n ]
                                whileTrue:
                                        [ ip := i + lev1.
                                        temp2 := (data at: ip) * temp.
                                        data at: ip put: (data at: i) - temp2.
                                        data at: i put: (data at: i) + temp2.
                                        i := i + lev ] ] ].
        self scaleData
]

1	"
2	A FastFourierTransform can be initialized with:
3	FastFourierTransform data: anArrayOfNumbersOrComplex
4	you can look at the data with #data, #realData and #imaginaryData.
5	#transform calculates the Fourier transform (in place, iow you get the transform again with #data etc) and #inverseTransform does the inverse.
6	"
7	Class {
8	#name : #PMFastFourierTransform,
9	#superclass : #Object,
10	#instVars : [
11	'nu',
12	'n',
13	'sinTable',
14	'permTable',
15	'data'
16	],
17	#category : #'Math-FastFourierTransform'
18	}
19
20	{ #category : #'instance creation' }
21	PMFastFourierTransform class >> data: anArrayOfNumbersOrComplex [	3✔
22	^ self new	3✔
23	data: anArrayOfNumbersOrComplex;	3✔
24	yourself	3✔
25	]	3✔
26
27	{ #category : #accessing }
28	PMFastFourierTransform >> chop: tolerance [	3✔
29	"sets numbers smaller than tolerance to zero"	3✔
30		3✔
31	\| r i \|	3✔
32	^ data := data	3✔
33	collect:	3✔
34	[ :k \|	3✔
35	r := k real.	3✔
36	i := k imaginary.	3✔
37	r abs < tolerance	3✔
38	ifTrue: [ r := 0 ].	3✔
39	i abs < tolerance	3✔
40	ifTrue: [ i := 0 ].	3✔
41	PMComplexNumber real: r imaginary: i ]	3✔
42	]	3✔
43
44	{ #category : #accessing }
45	PMFastFourierTransform >> data [	×
46	^ data	×
47	]	×
48
49	{ #category : #accessing }
50	PMFastFourierTransform >> data: anArrayOfNumberOrComplex [	3✔
51	\| aSize \|	3✔
52	aSize := anArrayOfNumberOrComplex size.	3✔
53	aSize < 4	3✔
54	ifTrue: [ ^ self error: 'dataSize must be at least 4' ].	3✔
55	aSize isPowerOfTwo	3✔
56	ifFalse: [ ^ self error: 'dataSize must be a power of two' ].	3✔
57	data := anArrayOfNumberOrComplex collect: [ :i \| i asComplex ] as: Array.	3✔
58	n = aSize	3✔
59	ifTrue: [ ^ data ].	3✔
60	"initialize the rest:"	3✔
61	n := aSize.	3✔
62	nu := (aSize log: 2) asInteger.	3✔
63	self initPermTable.	3✔
64	self initSinTable.	3✔
65	^ data	3✔
66	]	3✔
67
68	{ #category : #accessing }
69	PMFastFourierTransform >> imaginaryData [	3✔
70	^ data collect: [ :i \| i imaginary ]	3✔
71	]	3✔
72
73	{ #category : #initializing }
74	PMFastFourierTransform >> initPermTable [	3✔
75	\| r \|	3✔
76	permTable := OrderedCollection new: n // 2.	3✔
77	2 to: n - 1 do: [ :i \|	3✔
78	r := (i - 1 bitReverse: nu) + 1.	3✔
79	r > i	3✔
80	ifTrue: [ permTable	3✔
81	add: (Array with: i with: r) ] ]	3✔
82	]	3✔
83
84	{ #category : #initializing }
85	PMFastFourierTransform >> initSinTable [	3✔
86	\| d \|	3✔
87	d := n // 2.	3✔
88	sinTable := (0 to: n // 4) collect: [ :i \| (Float pi * i / d) sin ]	3✔
89	]	3✔
90
91	{ #category : #evaluation }
92	PMFastFourierTransform >> inverseTransform [	3✔
93	self transformForward: false.	3✔
94	^ data	3✔
95	]	3✔
96
97	{ #category : #private }
98	PMFastFourierTransform >> multiplier: theta [	3✔
99	^ theta < (n // 4)	3✔
100	ifTrue:	3✔
101	[ PMComplexNumber real: (sinTable at: sinTable size - theta) imaginary: (sinTable at: theta + 1) ]	3✔
102	ifFalse:	3✔
103	[ PMComplexNumber	3✔
104	real: (sinTable at: theta - (n // 4) + 1) negated	3✔
105	imaginary: (sinTable at: n // 2 - theta + 1) ]	3✔
106	]	3✔
107
108	{ #category : #accessing }
109	PMFastFourierTransform >> n [	×
110	^ n	×
111	]	×
112
113	{ #category : #accessing }
114	PMFastFourierTransform >> realData [	3✔
115	^ data collect: [ :i \| i real ]	3✔
116	]	3✔
117
118	{ #category : #private }
119	PMFastFourierTransform >> scaleData [	3✔
120	\| temp \|	3✔
121	temp := n sqrt.	3✔
122	data := data collect: [ :j \| PMComplexNumber real: j real / temp imaginary: j imaginary / temp ] "minimizes floating point error this way"	3✔
123	]	3✔
124
125	{ #category : #evaluation }
126	PMFastFourierTransform >> transform [	3✔
127	self transformForward: true.	3✔
128	^ data	3✔
129	]	3✔
130
131	{ #category : #private }
132	PMFastFourierTransform >> transformForward: forward [	3✔
133	\| lev lev1 ip temp temp2 i \|	3✔
134	permTable do: [ :j \| data swap: j first with: j second ].	3✔
135	1 to: nu do:	3✔
136	[ :level \|	3✔
137	lev := 1 bitShift: level.	3✔
138	lev1 := lev // 2.	3✔
139	1 to: lev1 do:	3✔
140	[ :j \|	3✔
141	temp := self multiplier: (j - 1) * (n // lev).	3✔
142	forward	3✔
143	ifFalse: [ temp := temp complexConjugate ].	3✔
144	i := j.	3✔
145	[ i <= n ]	3✔
146	whileTrue:	3✔
147	[ ip := i + lev1.	3✔
148	temp2 := (data at: ip) * temp.	3✔
149	data at: ip put: (data at: i) - temp2.	3✔
150	data at: i put: (data at: i) + temp2.	3✔
151	i := i + lev ] ] ].	3✔
152	self scaleData	3✔
153	]	3✔

PolyMathOrg / PolyMath / 4385132063

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous