I know Matlab is supposed to be widely used on "The Street" for modelling, but I don't think it is widely used as a trading platform partly because of the issues you mentioned in your post. However I still think that it is an interesting alternative to MetaTrader (anything but that s...) if you are an experienced Matlab user.
CB, Barhopper..
I implemented the FNN idea for identifying the "best" timeframe to trade a given pair -- running it against the EURUSD on tick data from November 15-28 showed that 33 mins seemed to have the lowest percentage of FNN (38.33%), using a dimension of 10 and a threshold of 0.10 (yes, I made that up). Most of the literature suggests using a threshold of 10-50, but given that we are dealing with currencies at 4 decimal places, I figured it was pretty unlikely to see distances of that scale. Does that sound right/logical? If not, how do you choose the threshold?
Other pairs reflect similarly for the same timeframe -- USDJPY @ 33 mins w/ 39% FNN, GBPUSD @ 32 mins w/ 36% FNN. 30 minutes def seems to be a sweet spot at this date/time, assuming a.) my analysis is right b.) this technique actually works.
Of course, the next step is to see if there is any meaningful difference by running the ULLMA+Goertzel and seeing if there is any correlation between "best" timeframe and performance. From what I've read about FNN, I don't think this is really the way it's supposed to be used, but it sounds like an interesting idea.
I implemented the FNN idea for identifying the "best" timeframe to trade a given pair -- running it against the EURUSD on tick data from November 15-28 showed that 33 mins seemed to have the lowest percentage of FNN (38.33%), using a dimension of 10 and a threshold of 0.10 (yes, I made that up). Most of the literature suggests using a threshold of 10-50, but given that we are dealing with currencies at 4 decimal places, I figured it was pretty unlikely to see distances of that scale. Does that sound right/logical? If not, how do you choose the threshold?
Other pairs reflect similarly for the same timeframe -- USDJPY @ 33 mins w/ 39% FNN, GBPUSD @ 32 mins w/ 36% FNN. 30 minutes def seems to be a sweet spot at this date/time, assuming a.) my analysis is right b.) this technique actually works.
Of course, the next step is to see if there is any meaningful difference by running the ULLMA+Goertzel and seeing if there is any correlation between "best" timeframe and performance. From what I've read about FNN, I don't think this is really the way it's supposed to be used, but it sounds like an interesting idea.
The symmetry of FFT should guarrantee that Goertzel and FFT are equivalent.
To prove it, I think we need to create a new series xprime, which is half the length of x.
xprime is a complex valued vector where x was real.
The even numbered index elements of x go into the real values of xprime.
The odd numbered index elements of x go into the imaginary values of xprime.
so
xprime = x(even) + i*x(odd)
Then take the FFT of xprime.
output1 = fft(xprime);
output2 = output1((N/2
1)'); (reverse the order of the elements)
output2 = real(output2) + i*imag(output2); (complex conjugate)
output = (1/2)*(output1+output2)...
-(1/2)*i*(output1-output2) .* exp(2*pi*i*((0:N/2-1)')/(N/2));
fftAmplitude = sqrt(real(output).^2 + imag(output).^2);
There might be one or two more tricks involved in getting this to work out exactly, but I think this is the rough outline for proving that FFT and Goertzel are equivalent even in the case I mentioned in the previous note.
If someone has the exact algorithm, maybe they can post it. But this is the basic idea.
Ngawang
To prove it, I think we need to create a new series xprime, which is half the length of x.
xprime is a complex valued vector where x was real.
The even numbered index elements of x go into the real values of xprime.
The odd numbered index elements of x go into the imaginary values of xprime.
so
xprime = x(even) + i*x(odd)
Then take the FFT of xprime.
output1 = fft(xprime);
output2 = output1((N/2
1)'); (reverse the order of the elements)output2 = real(output2) + i*imag(output2); (complex conjugate)
output = (1/2)*(output1+output2)...
-(1/2)*i*(output1-output2) .* exp(2*pi*i*((0:N/2-1)')/(N/2));
fftAmplitude = sqrt(real(output).^2 + imag(output).^2);
There might be one or two more tricks involved in getting this to work out exactly, but I think this is the rough outline for proving that FFT and Goertzel are equivalent even in the case I mentioned in the previous note.
If someone has the exact algorithm, maybe they can post it. But this is the basic idea.
Ngawang
Hi all,
I've implemented the Goertzel DFT in my programming language of choice and, like adamant, have been running known signals through it to test that it's working correctly. One thing that I don't understand (and this is likely due to my poor grasp of the math behind the DFT) is why the magnitude returned out of the DFT is so large. For example, if I generate a simple sine wave with frequency of 1/60 and run it through my goertzel (Python code below), I'll get back an amplitude of 89.51 and phase of -1.571. The amplitude is far beyond what the original wave was -- is it scaled in some way? Is there a way to recover the original amplitude, or am I missing some fundamental concept here? I did notice that for each notch I increase amplitude, in the original function, the output of gx() is approx pi/2 * amp -- but I'm not sure what it means.
Any help/guidance would be appreciated.
I've implemented the Goertzel DFT in my programming language of choice and, like adamant, have been running known signals through it to test that it's working correctly. One thing that I don't understand (and this is likely due to my poor grasp of the math behind the DFT) is why the magnitude returned out of the DFT is so large. For example, if I generate a simple sine wave with frequency of 1/60 and run it through my goertzel (Python code below), I'll get back an amplitude of 89.51 and phase of -1.571. The amplitude is far beyond what the original wave was -- is it scaled in some way? Is there a way to recover the original amplitude, or am I missing some fundamental concept here? I did notice that for each notch I increase amplitude, in the original function, the output of gx() is approx pi/2 * amp -- but I'm not sure what it means.
Any help/guidance would be appreciated.
Inserted Code
import numpy as np
import matplotlib.pyplot as plot
TWO_PI = 2 * np.pi
def gx(x, omega):
s1 = s2 = 0.0
zeta = 2.0 * np.cos(2.0 * np.pi * omega)
for i in range(0, len(x)):
s = x[i] + zeta * s1 - s2
s2 = s1
s1 = s
real = s1 * (zeta / 2) - s2
imag = s2 * np.sin(2.0 * np.pi * omega)
amplitude = np.sqrt(np.power(real, 2) + np.power(imag,2))
phase = np.arctan2(imag, real)
return (amplitude, phase)
def wave(amp, freq, phase, x):
return amp * np.sin(TWO_PI * freq * x + phase)
x = np.arange(0.0, 180.0)
y = wave(1, 1/60.0, 0, x)
(amp, phase) = gx(y, 1/60.0)
print amp, phase - #440
- Mar 7, 2009 12:27am Mar 7, 2009 12:27am
- Joined Nov 2005 | Status: EURUSD Quant FREAK | 3,197 Posts
