pacois wrote: Thu Sep 26, 2019 1:45 am Hi, fxtimer has disappeared? Here at Forex Station disappeared Martiwana is everyone thinks he found the miraculous indicator !!

Could very well be actually. FFT indicators are not as bad as people make them out to be. Personally I find them to be the best indicators in the category of 'repaint indicators'.

shaileshm wrote: Thu Sep 26, 2019 3:15 pm Could very well be actually. FFT indicators are not as bad as people make them out to be. Personally I find them to be the best indicators in the category of 'repaint indicators'.

thx shail............. interesting....... what is ur favourite one out of the fft's?? could u post one up for us pls?

moey_dw wrote: Thu Sep 26, 2019 3:26 pm

thx shail............. interesting....... what is ur favourite one out of the fft's?? could u post one up for us pls?

this one

viewtopic.php?p=1295321502#p1295321502

but i load the indi multiple times with different parameters. i will be doing a review on this but default settings are not the best. Also i find composite cycle view better.

Mladen had made a version which had peak identifiers and also one where it would draw resistance lines on the chart at peaks. It would be great if someone could get them.

moey_dw wrote: Wed Sep 25, 2019 8:32 pm

its called fast fourier transform............... repaints

FFT doesn't mean it repaints necessarily but it is not very good at filtering
also you have to prepare the data because FT thinks that the frequencies are seamless and it causes artifacts at endpoints if not done correctly.
a good paper on it

I know one guy that could help to identify fxtimer, his nick in forex factory is simba or simbafx i dont remember well. The problem is i dont know if that guy is in this forum

ionone wrote: Thu Sep 26, 2019 6:54 pm

FFT doesn't mean it repaints necessarily but it is not very good at filtering
also you have to prepare the data because FT thinks that the frequencies are seamless and it causes artifacts at endpoints if not done correctly.
a good paper on it

I have some papers that fxtimer told they were neccesary to create vfft. But here i dont know if there are people interested in making that.

zer0Code wrote: Wed Sep 25, 2019 7:43 pm hello lads,
I just saw the best indicator we can have.It is called vfft. Anyone knows how to get it or who have it?vfftsell.jpg

Also on Forex factors ran into him?
Though give an explanation that it is -
"Finally, I found something that has been working consistently ... a special kind of FFT, its name is VFFT (Very Fast Fourier Transform)."

Hello everyone, everything good? Passing by to share something I found in my research.

From what I read, there was a lot of demand for this version of the Very Fast Fourier Transform.

I think Loxx created something along these lines.

It is worth remembering that predictive indicators repaint, but if you are interested, here it is for your analysis.

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © loxx

//@version=5
indicator("Real-Fast Fourier Transform of Price w/ Linear Regression [Loxx]",
shorttitle = "RFFTP [Loxx]",
overlay = true,
max_lines_count = 500)

greencolor = #2DD204
redcolor = #D2042D

//+-------------------------------------------------------------------------+
//| Real Fast Fourier Transform |
///+-------------------------------------------------------------------------+
//The algorithm performs a fast Fourier transform of a real
//function defined by n samples on the real axis.
//
//Depending on the passed parameters, it can be executed
//both direct and inverse conversion.
//
// Input parameters:
// tnn - Number of function values. Must be degree
// deuces. Algorithm does not validate
// passed value.
// a - array [0 .. nn-1] of Real
// Function values.
// InverseFFT
// - the direction of the transformation.
// True if reverse, False if direct.
//
// Output parameters:
// a - the result of the transformation.
//
// For more details, see description on the site:
// https://www.alglib.net/fasttransforms/fft.php
// https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.205.4523&rep=rep1&type=pdf
//+-------------------------------------------------------------------------+

_realFastFourierTransform(float[] a, int tnn, bool inversefft)=>
float twr = 0.
float twi = 0.
float twpr = 0.
float twpi = 0.
float twtemp = 0.
float ttheta = 0.
int i = 0
int i1 = 0
int i2 = 0
int i3 = 0
int i4 = 0
float c1 = 0.
float c2 = 0.
float h1r = 0.
float h1i = 0.
float h2r = 0.
float h2i = 0.
float wrs = 0.
float wis = 0.
int nn = 0
int n = 0
int mmax = 0
int m = 0
int j = 0
int istep = 0
int isign = 0
float wtemp = 0.
float wr = 0.
float wpr = 0.
float wpi = 0.
float wi = 0.
float theta = 0.
float tempr = 0.
float tempi = 0.

if (tnn != 1)
if (not inversefft)
ttheta := 2.0 * math.pi / tnn
c1 := 0.5
c2 := -0.5
else
ttheta := 2.0 * math.pi / tnn
c1 := 0.5
c2 := 0.5
ttheta := -ttheta
twpr := -2.0 * math.pow(math.sin(0.5 * ttheta), 2)
twpi := math.sin(ttheta)
twr := 1.0 + twpr
twi := twpi

for ix = 2 to tnn / 4 + 1
i1 := ix + ix - 2
i2 := i1 + 1
i3 := tnn + 1 - i2
i4 := i3 + 1
wrs := twr
wis := twi
h1r := c1 * (array.get(a, i1) + array.get(a, i3))
h1i := c1 * (array.get(a, i2) - array.get(a, i4))
h2r := -c2 * (array.get(a, i2) + array.get(a, i4))
h2i := c2 * (array.get(a, i1) - array.get(a, i3))
array.set(a, i1, h1r + wrs * h2r - wis * h2i)
array.set(a, i2, h1i + wrs * h2i + wis * h2r)
array.set(a, i3, h1r - wrs * h2r + wis * h2i)
array.set(a, i4, -h1i + wrs * h2i + wis * h2r)
twtemp := twr
twr := twr * twpr - twi * twpi + twr
twi := twi * twpr + twtemp * twpi + twi


h1r := array.get(a, 0)
array.set(a, 0, c1 * (h1r + array.get(a, 1)))
array.set(a, 1, c1 * (h1r - array.get(a, 1)))

if (inversefft)
isign := -1
else
isign := 1

n := tnn
nn := tnn / 2
j := 1
for ii = 1 to nn
i := 2 * ii - 1
if (j > i)
tempr := array.get(a, j - 1)
tempi := array.get(a, j)
array.set(a, j - 1, array.get(a, i - 1))
array.set(a, j, array.get(a, i))
array.set(a, i - 1, tempr)
array.set(a, i, tempi)

m := n / 2
while (m >= 2 and j > m)
j := j - m
m := m / 2

j := j + m

mmax := 2
while (n > mmax)
istep := 2 * mmax
theta := 2.0 * math.pi / (isign * mmax)
wpr := -2.0 * math.pow(math.sin(0.5 * theta), 2)
wpi := math.sin(theta)
wr := 1.0
wi := 0.0
for ii = 1 to mmax / 2
m := 2 * ii - 1
for jj = 0 to (n - m) / istep
i := m + jj * istep
j := i + mmax
tempr := wr * array.get(a, j - 1) - wi * array.get(a, j)
tempi := wr * array.get(a, j) + wi * array.get(a, j - 1)
array.set(a, j - 1, array.get(a, i - 1) - tempr)
array.set(a, j, array.get(a, i) - tempi)
array.set(a, i - 1, array.get(a, i - 1) + tempr)
array.set(a, i, array.get(a, i) + tempi)

wtemp := wr
wr := wr * wpr - wi * wpi + wr
wi := wi * wpr + wtemp * wpi + wi

mmax := istep

if (inversefft)
for ix = 1 to 2 * nn
array.set(a, ix - 1, array.get(a, ix - 1) / nn)

if (not inversefft)
twpr := -2.0 * math.pow(math.sin(0.5 * ttheta), 2)
twpi := math.sin(ttheta)
twr := 1.0 + twpr
twi := twpi

for ix = 2 to tnn / 4 + 1
i1 := ix + ix - 2
i2 := i1 + 1
i3 := tnn + 1 - i2
i4 := i3 + 1
wrs := twr
wis := twi
h1r := c1 * (array.get(a, i1) + array.get(a, i3))
h1i := c1 * (array.get(a, i2) - array.get(a, i4))
h2r := -c2 * (array.get(a, i2) + array.get(a, i4))
h2i := c2 * (array.get(a, i1) - array.get(a, i3))
array.set(a, i1, h1r + wrs * h2r - wis * h2i)
array.set(a, i2, h1i + wrs * h2i + wis * h2r)
array.set(a, i3, h1r - wrs * h2r + wis * h2i)
array.set(a, i4, -h1i + wrs * h2i + wis * h2r)
twtemp := twr
twr := twr * twpr - twi * twpi + twr
twi := twi * twpr + twtemp * twpi + twi

h1r := array.get(a, 0)
array.set(a, 0, h1r + array.get(a, 1))
array.set(a, 1, h1r - array.get(a, 1))
a

//linear regression value
_iLRValue(float[] src, float period, float slope)=>
float SumXY = 0.
float SumY = 0.
float sumX = period * (period - 1) / 2.0
float sumXX = period * (period - 1) * (2.0 * period - 1.0) / 6.0
float divisor = math.pow(sumX, 2.0) - period * sumXX

slope1 = slope
for k = 0 to period - 1
SumXY += k * array.get(src, k)
SumY += array.get(src, k)

if (divisor != 0)
slope1 := (period * SumXY - sumX * SumY) / divisor
else
slope1 := 0
out = ((SumY - slope1 * sumX) / period + slope1 * (period - 1.0))
[out, slope1]

src = input.source(close, "Source", group = "Basic Settings")
uselreg = input.bool(true, "Use Linear Regression?", group = "Basic Settings")
Windowin = input.string("512", "Window", options = ["4", "8", "16", "32", "64", "128", "256", "512", "1024", "2048"], group = "Basic Settings")
Treshold = input.float(0.03, "Treshold", step = 0.001, group = "Basic Settings")
dtrendper = input.int(0, "Detrended Line Period", group = "Basic Settings")
barsback = input.int(30, "Last Bar", minval = 0, group = "Basic Settings")
mutebars = input.bool(true, "Bar color muting?", group = "Basic Settings")

//+------------------------------------------------------------------+
//| Initialize variables
//+------------------------------------------------------------------+

var pvlines = array.new_line(0)
var lrlines = array.new_line(0)

//+------------------------------------------------------------------+
//| Force input Window period to lowest nearest power of 2,
//| we alreadsy solved to make sure user can
//| only select powers of 2
//+------------------------------------------------------------------+

Window = str.tonumber(Windowin)
n = int(math.log(Window) / math.log(2))
N = int(math.max(math.pow(2, n), 16))

barcolor(mutebars ? last_bar_index - bar_index >= barsback and last_bar_index - bar_index < N ? color.gray : na : na)

//+------------------------------------------------------------------+
//| Initialize lines for drawing later
//+------------------------------------------------------------------+
countout = Window >= 256 ? 250 : Window
if barstate.isfirst
for i = 0 to countout - 1
array.push(pvlines, line.new(na, na, na, na))
array.push(lrlines, line.new(na, na, na, na))

//+------------------------------------------------------------------+
//| Core compute
//+------------------------------------------------------------------+
if barstate.islast

//+------------------------------------------------------------------+
//| Initial variables
//+------------------------------------------------------------------+
dlLength = dtrendper > N or dtrendper < 1 ? N : dtrendper
work = array.new<float>(N, 0.)
price = array.new<float>(N, 0.)
lr = array.new<float>(N, 0.)
fft = array.new<float>(N, 0.)

for i = 0 to N - 1
array.set(price, i, nz(src[i + barsback]))

endValue = 0.
slope = 0.

//+------------------------------------------------------------------+
//| Apply Linear Regression and detrending
//+------------------------------------------------------------------+
if (uselreg)
[dv, slp] = _iLRValue(price, dlLength, slope)
endValue := dv
slope := slp
else
endValue := array.get(price, 0)
slope := (endValue - array.get(price, dlLength - 1)) / dlLength

for i = N - 1 to 0
array.set(lr, i, endValue - slope * i)
array.set(work, i, array.get(price, i) - array.get(lr, i))

//+------------------------------------------------------------------+
//| Apply Regular FFT and calculate powers and modified by threshhold
//+------------------------------------------------------------------+
_realFastFourierTransform(work, N, false)

for i = 1 to N / 2 - 1
amp = math.sqrt(math.pow(array.get(work, i * 2), 2) + math.pow(array.get(work, i * 2 + 1), 2))
add = 0.
if (not (array.get(work, i * 2) > 0))
add := math.pi
phase = math.atan(array.get(work, i * 2 + 1) / array.get(work, i * 2))
array.set(work, i * 2, amp * math.cos(phase + add))
array.set(work, i * 2 + 1, amp * math.sin(phase + add))

power = 0.
for i = 1 to N / 2 - 1
power += math.sqrt(math.pow(array.get(work, i * 2), 2) + math.pow(array.get(work, i * 2 + 1), 2))
treshold = power * Treshold

for i = 1 to N / 2 - 1
tmp = math.sqrt(math.pow(array.get(work, i * 2), 2) + math.pow(array.get(work, i * 2 + 1), 2))
if (tmp < treshold)
array.set(work, i * 2, 0)
array.set(work, i * 2 + 1, 0)

//+------------------------------------------------------------------+
//| Apply Inverse FFT and final output
//+------------------------------------------------------------------+
_realFastFourierTransform(work, N , true)
for i = 0 to N - 1
array.set(fft, i, array.get(work, i) + array.get(lr, i))

skipper = Window == 2048 ? 8 : Window == 1024 ? 4 : Window == 512 ? 2 : 1
int i = 0
int j = 0

//+------------------------------------------------------------------+
//| Draw lines w/ skipping to stay within 500 line limit
//+------------------------------------------------------------------+
while i < N and i < array.size(fft) - 2

if j > array.size(pvlines) - 1
break
pvline = array.get(pvlines, j)
colorout = i < array.size(fft) - 2 ? array.get(fft, i) > array.get(fft, i + skipper) ? greencolor : redcolor : na
line.set_xy1(pvline, bar_index - i - skipper - barsback, array.get(fft, i + skipper))
line.set_xy2(pvline, bar_index - i - barsback, array.get(fft, i))
line.set_color(pvline, colorout)
line.set_style(pvline, line.style_solid)
line.set_width(pvline, 5)

lrline = array.get(lrlines, j)
colorout2 = i < array.size(lr) - 2 ? array.get(lr, i) > array.get(lr, i + skipper) ? greencolor : redcolor : na
line.set_xy1(lrline, bar_index - i - skipper - barsback, array.get(lr, i + skipper))
line.set_xy2(lrline, bar_index - i - barsback, array.get(lr, i))
line.set_color(lrline, colorout2)
line.set_style(lrline, line.style_solid)
line.set_width(lrline, 2)

i += skipper
j += 1



Note: I'm posting just for analysis, I don't know if this indicator can actually be used in trading, as I noticed that it repaints strongly.