We are proud to be able to offer our FDCPRO users dedicated Jurik Research functionality (http://www.jurikres.com/). The descriptions below explain how the DLL version of the Jurik Research functions work in FDC. A more general understanding of the functions can be found in Jurik's own manuals. The functionality of the FDC versions is sometimes a bit different from that expressed in the Jurik manuals, as we have endeavored to make the interface between FDC and Jurik functions as simple and seamless as possible.
FDC presents the following guides:
REQUIREMENTS: You have the professional version of FDC, and a licensed copy of the DLL version of the Jurik Research Toolset. Note that Jurik software is PC-specific. That is, they will not work if copied to a different PC. Should you need to install Jurik software onto another computer, contact Jurik Research. (http://www.jurikres.com/)
IMPORTANT: If you purchased the DLL version of the Jurik Toolset after 1-SEP-05, then run Procedure A, otherwise run Procedure B.
Function: jrc_jma --- Jurik Moving Average.
syntax: N M jrc_jma [dataset]
N is the length of the smoother. Larger N produces a smoother curve. N may be any non-negative value.
Typical values are between 5 and 20.
M controls the filter's inertia. More positive M delivers less lag but more overshoot during reversals in
direction of the time series. M must be between -100 and +100 inclusive. A good compromise is when M=0.
Dataset must have at least 31 elements (data points).
NOTES: The first 30 rows of output are not smoothed data and are dropped.
The dataset may have any number of columns, which are processed separately by jrc_jma.
---------------------------------------------------------------------------------------
Function: jrc_vel --- Jurik Velocity oscillator.
syntax: N jrc_vel [dataset]
N is the depth parameter, which is analogous to the window size of a classical momentum oscillator.
N may be any integer between 1 and 500. Typical values range from 5 to 20.
Dataset must have at least N+1 or 31 rows of data points, whichever is greater.
NOTES: The first R rows of output are simply 0 and are dropped. R=maximum(N, 30).
The dataset may have any number of columns, which are processed separately by jrc_vel.
---------------------------------------------------------------------------------------
Function: jrc_cfb --- Jurik Composite Fractal Behavior Index.
syntax: N M jrc_cfb [dataset]
N is the smoother. Larger values produce smoother results. N must be between 1 and 50.
M is the fractal window size. M must be either 24, 48, 96 or 192.
Dataset must have at least M+N rows of data.
NOTES: The first M + 6 rows of the output are not relevant, and are dropped.
The dataset may have any number of columns, which are processed separately by jrc_cfb.
---------------------------------------------------------------------------------------
Function: jrc_dmx --- Jurik Directional Movement Index.
syntax: N jrc_dmx [dataset]
N is the function length. Note that N must be between 2 and 500 inclusive. Typical values range
from 10 to 30.
Dataset must have exactly three columns, which must represent the High, Low, and Close of the data.
Dataset needs at least 41 rows of input data.
NOTES: The output will have three columns representing the bipolar DMX, plus DMX and minus DMX, in that order. The first 40 rows of output are 0, and are therefore removed.
---------------------------------------------------------------------------------------
Function: jrc_rsx --- Jurik Relative Strength Index
syntax: N jrc_rsx [dataset]
N is the function length. Larger N produces slower movement. N must be between 2 and 500 inclusive.
Typical values range from 5 to 20.
Dataset must have at least 32 rows.
NOTES: The first 29 rows of output are not relevant, and are dropped.
The dataset may have any number of columns, which are processed separately.
---------------------------------------------------------------------------------------
Function: jrc_wav --- Jurik Waveform Compressor. Output is an array.
syntax: N M jrc_wav [dataset]
N specifies the number of output columns.
M is the mode, which can be either 1, 2 or 3, described as follows. See the Jurik user manual on WAV for more
details.
Dataset must have at least W elements down the column, where W is the window size as specified in the WAV table.
NOTES: The first (W-1) rows will have 0 as the output.and will be deleted. W is the window size as specified in the WAV table.
---------------------------------------------------------------------------------------
Function: jrc_ddr --- Jurik Decorrelator and Dimension Reducer. Output is an array.
syntax: jrc_ddr [dataset]
Dataset must have at least 2 columns with at least 3 rows.
NOTES: Output data array is the same size as the input data array.
FDC version puts labels on the output columns specifying the percentage of total signal represented by each column.
The Jurik Moving Average (JMA)
The JMA is a non-linear smoother that can be used as one would use any other data smoother.
Function: jrc_jma
Syntax: N M jrc_jma [dataset]
N is the length of the smoother. Larger N produces a smoother curve. N may be any non-negative value.
Typical values are between 5 and 20.
M controls the filter's inertia. More positive M delivers less lag but more overshoot during reversals in
direction of the time series. M must be between -100 and +100 inclusive. A good compromise is when M=0.
Dataset must have at least 31 elements (data points).
NOTES: The first 30 rows of output are not smoothed data and are dropped.
The dataset may have any number of columns, which are processed separately by jrc_jma.
Consider the following example. Many of these operations could be combined or put into a one-word macro.
In the chart below we illustrate a 40 0 JMA of the close as an overlay on the S&P bar chart. The lower pane shows an oscillator created by subtracting a double linear-weighted 30-day moving average from a 7 50 JMA .
VEL: The Jurik Zero-Lag Velocity Indicator
The JMA VEL is a super-smooth version of the technical indicator “momentum” with the special feature that the smoothing process has added no additional lag to the original momentum indicator.
Function: jrc_vel
Syntax: N jrc_vel [dataset]
N is the depth parameter, which is analogous to the window size of a classical momentum oscillator.
N may be any integer between 1 and 500. Typical values range from 5 to 20.
Dataset must have at least N+1 or 31 rows of data points, whichever is greater.
NOTES: The first R rows of output are simply 0 and are dropped. R=maximum(N, 30).
The dataset may have any number of columns, which are processed separately by jrc_vel.
Consider the following example. Many of these operations could be combined or put into a one-word macro.
The last line instructs FDC to create an automatic plot. The first pane shows the NASDAQ composite. The lower pane shows a 15-bar VEL oscillator on the closing price.
RSX: The Jurik Relative Strength Index
The popular RSI indicator is very noisy. The Jurik RSX eliminates noise completely; and its smoothness comes without added lag.
Function: jrc_rsx
Syntax: N jrc_rsx [dataset]
N is the function length. Larger N produces slower movement. N must be between 2 and 500 inclusive.
Typical values range from 5 to 20.
Dataset must have at least 32 rows.
NOTES: The first 29 rows of output are not relevant, and are dropped.
The dataset may have any number of columns, which are processed separately.
Consider the following example. Many of these operations could be combined or put into a one-word macro.
The last line instructs FDC to create an automatic plot. The first pane shows the 30-year US Treasury Bonds. The lower pane shows a 15-bar RSX oscillator on the closing price.
DMX: The Jurik Directional Movement Index
The Jurik DMX is a super-smooth version of the technical indicator DMI, while retaining very fast response speed. Low-lag super-smoothing means the DMX signal has less noise (yielding fewer false alarms) and less delay than DMI.
Function: jrc_dmx
Syntax: N jrc_dmx [dataset]
N is the function length. Note that N must be between 2 and 500 inclusive. Typical values range
from 10 to 30.
Dataset must have exactly three columns, which must represent the High, Low, and Close of the data.
Dataset needs at least 41 rows of input data.
NOTES: The output will have three columns representing the bipolar DMX, plus DMX and minus DMX, in that order. The first 40 rows of output are 0, and are therefore removed.
Consider the following example. Many of these operations could be combined or put into a one-word macro.
Note that variable temp3 is a 3-column dataset, which is an output requirement of DMX. These three values are expressed in the lower two panes.
CFB: The Jurik Composite Fractal Behavior Index
The Jurik CFB reveals the length of the market’s trend. Long trending activity produces a large index value; and short, choppy action produces a small index value. CFB can be used as an indicator alone, or as an adaptive input for other indicators.
Function: jrc_cfb
Syntax: N M jrc_cfb [dataset]
N is the smoother. Larger values produce smoother results. N must be between 1 and 50.
M is the fractal window size. M must be either 24, 48, 96 or 192.
Dataset must have at least M+N rows of data.
NOTES: The first M + 6 rows of the output are not relevant, and are dropped.
The dataset may have any number of columns, which are processed separately by jrc_cfb.
Consider the following example. Many of these operations could be combined or put into a one-word macro.
This produces two panes: the upper pane shows the EURO and the lower pane shows a 21 48 CFB on the closing price.
Line 5 of the FDC command set illustrated above created a moving average. However its input parameter (i.e. the moving average "length") for each bar was the CFB output value for each bar. If the CFB for a particular bar was 8, then an 8-day moving average was created for that bar. On another bar, the CFB would have been 25, in which case a 25-day moving average would have been created. The plot of the price (with that adaptive moving average) is shown below:
Note the jaggedness of the moving average at certain locations. This occurs because the simple moving average (SMA) is calculated from "scratch" at every bar, and is oblivious to whatever the moving average was on the previous bar. To get less jagged results, use an exponential moving average (EMA). The EMA operates by making adjustments to its prior output value, thereby avoiding the "jaggies".
WAV: The Jurik Waveform Compressor
Forecasting a time series involves feeding data to an algorithm (a forecast model) such as a neural net. Typically, smaller models are easier to develop and are less prone to excessive curve fitting. One way you can achieve a smaller model is by reducing the number of independent (input) variables being fed to the model. When the independent variables consist of a portion, or window, of elements in a long time series you can reduce the number of independent variables by compressing the windowed set of values into a smaller set of values. When compressing time series market data, in order to avoid losing relevant information, you need a form of compression that takes into consideration the fact that markets have a fading memory.
WAV is designed to perform the aforementioned compression of time series data.
WAV processes one column of time series data at a time. For each element in the input column,WAV produces a corresponding set of compressed values that extend as a row. Therefore, the complete output of WAV is a set of rows (an array).
Each successive row down WAV's output array corresponds to another window of historical data, shifted one element forward in time. In summary, WAV compresses data that resides within a window, outputs the result to a row, then shifts the window down (forward in time) by one element, compresses the new collection of historical values, outputs its results to the next row, and continues the process untill the leading edge of WAV's moving window reaches the end of the input column.
NOTE: The number of elements in WAV's output row is exactly the same as the number of columns in WAV's output. These two notions are used synonymously.
If you want to create a set of compressed values that spans deeper into history, WAV will need to apply a larger moving window and, consequently, produce more output columns. For example, setting WAV to produce an array of 18 columns allows WAV to apply a moving window that reads 398 historical values for each compression. Reducing 398 values to just 18 is a compression ratio of over 22-to-1. The table relates the number of WAV's output columns, moving window size, and effective compression ratio.
Function: jrc_wav
Syntax: N M jrc_wav [dataset]
N specifies the number of output columns.
M is the mode, which can be either 1, 2 or 3, described as follows. See the Jurik user manual on WAV for more
details.
Dataset must have at least W elements down the column, where W is the window size as specified in the table.
NOTES: The first (W-1) rows will have 0 as the output.and will be deleted. W is the window size as specified in the table.
The following command lines request the WAV function to operate on closing prices of the SPX. Parameter N is 10 (you want 10 output columns), the mode is 1 (standard processing, no detrending, no normalizing). The output is shown below. Typically WAV's output is not conducive to visual interpretation on a chart, as it is intended to be fed as independent variables into some data model.
DDR: The Jurik Decorrelator and Dimension Reducer
Data modeling algorithms are of two types. In the first type, you apply a set of equations that instantly yield the model's parameters. One popular example of this type is Linear Regression. Algorithms of this type are well researched and are used to model data when the functions used successfully mimic the hidden input/output relationship.
For more complex datasets, where the input/output relationship is completely unknown, a more general formula is applied, whereby the function that is needed actually evolves over time. Through repeated passes over the data (iterations), the function being modeled keeps getting better. Popular examples of this iterative approach include genetic algorithms and neural nets.
Research into neural nets has shown that fewer iterations are required, and overall performance is improved, when all the independent (input) variables are statisitcally independent of each other. In other words, when there is no redundancy (multicolinearity) among the independent variables. This makes sense because when two variables are similar, the model wastes time and resources trying to figure out how to differentiate between them. Therefore, decorrelating all independent variables before feeding them to a neural net should be standard practice. DDR decorrelates columns of data using an algorithm proven to always be stable and accurate.
DDR accepts a dataset of multiple columns and produces an array of the same number of columns.
It is important to keep in mind that the output columns of DDR typically do not resemble any of the input columns. Nonetheless, the information contained in each row of DDR output is exactly the same as the information contained within the corresponding row of input data. In other words, DDR throws away no information during the decorrelation process.
The user is not required to feed all output columns to a neural net. Some columns may carry most of the information needed to explain the data, and other columns carry hardly any information at all. It is not uncommon for DDR to decorrelate 200 technical indicators and determine that the first 15 output columns together contain over 98% of all the information spanned by the technical indicators, and the other 190 output columns together contain less than 2% !! Under these circumstances, feeding only the first 15 columns of DDR's output to a neural net is strongly recommended.
Along the top, DDR displays to what extent each output column explains all the input data, and the columns are sorted, from left to right, accordingly. DDR also shows the cumulative contribution, starting from the leftmost column. (See table.)
The leftmost columns of DDR's output are more important than the rightmost columns. When feeding DDR columns to a forecast model, start with a few leftmost columns first. If you want to feed another column to your model, add the next leftmost DDR column. The rightmost columns should be the last ones for consideration as they are more likely to represent data "noise".
The table was produced as follows:
Function: jrc_ddr
Syntax: jrc_ddr [dataset]
Dataset must have at least 2 columns with at least 3 rows.
In the following command set, line 3 has WAV producing an array of 10 columns, and line 4 has DDR decorrelating WAV's output array.
Most of DDR's output columns are not conducive to human interpretation and do not appear meaningful when viewed as a chart. For example, the above data when graphed is illustrated below. You can easily see why there is no point in looking at all the plots.
In some circumstances, the first few columns of DDR's output are smooth enough to be plotted on a chart as new technical indicators. The advantage with this approach is that these new column values are 100% uncorrelated with each other. Thus each of DDR's output columns produce totally different information, theoretically advantageous in technical analysis.
To better illustrate this, plots in the above chart are separated, two plots per chart, as shown below. As is always the case with DDR, the first plot is the slowest moving and each successive plot moves faster. Although the last few plots are unreadable, the first few can be quite useful. Jurik Research was informed by the research department of a very large bank in Europe (identity is secret) that when DDR was applied to their five most important market indicators, they found the first two output columns from DDR were easier to analyze and more useful than their original five!
NOTE -- When creating new indicators this way, make sure your favorite technical indicators (input variables to DDR) have a range bounded between two fixed values.
The FDC platform allows you to seamlessly input the result of all operations mentioned above directly into a neural network, train that neural network and produce a forecast.
One of the neural nets we support is Braincel . This can be obtained as a set of functions in a DLL file from Jurik Research for a very nominal price. The same file also comes with a full version of Braincel (also sold by Jurik Research) which allows the user to operate Braincel in Microsoft Excel. Either way, place a copy of the Braincel DLL file (whose name is tradecel.dll) into the folder "[main FDC folder]\experts\braincel".
FDC also supports other neural nets, whose input data can be preprocessed in the same way.
In the example shown below (not intended to be realistic) we illustrate how data is ...
We recognize that the code set below may seem a little intimidating. It is followed up with a line-by-line explanation.
Line 1 resets all temporary dataset variable names to zero.
Line 2 calls up the dataset SPX and takes its closing price for the last 600 days. The line also saves the creation as a temporary dataset with the name “shortspxcl”. Temporary datasets are not permanently saved in your data folder, but expire when FDC is closed.
Line 3 takes the 7-day Jurik VEL of shortspxcl, divides it by 10 (to bring its order of magnitude in line with other data), and saves it as a temporary dataset named “velspx”.
Line 4 creates a 5 15 Jurik JMA moving average of shortspx, and calls it “jmaspx”.
Line 5 “detrends” jmaspx by taking the difference between it and its 50 day moving average, calling that difference “diffjma”.
Line 6 divides diffjma by 100 (reordering its magnitude) and names it “normjma”.
Line 7 puts together (in columns) shortspxcl, jmaspx and normjma. Any rows having blanks in the combined dataset (resulting from some operations having no output for the initial days) are killed off by the killblanks function. The result is named “input1”.
Line 8 modifies data “outliers”. This is done by using trimpercent to trim off the top 5 percent and bottom 5 percent of the data that is in input1. That data is not discarded, but replaced with values equal to that at the 5th and 95th percentile. The result is named “input2”.
Line 9 uses the Jurik WAV to produce 8 columns of output for each column of entry data, using standard mode filtering. WAV reads in input2 and produces the array named “input3”.
Line 10 uses the Jurik DDR function to decorrelate and rank the array input3 and create “input” with only the first (most important) ten columns.
Line 11 defines the “target” as the 5-day change in the close of SPX five days ahead.
Line 12 puts together the input with the target, killing off blanks and naming the dataset “bcsnp”.
Line 13 takes all but the last 100 data entries of bcsnp. This will be the training set for the neural net and is named “bcsnp1”.
Line 14 trains the neural network. Please see the instructions in the Braincel manual for the various parameters. Parameters are also outlined in FDC’s Neural Network Wizard, aka the "brain button".
Line 15 asks the created neural network to perform its function on the last 100 days of input data as it has been trained on the earlier data. The output is the predicted data named “pred”.
Line 16 renames “target” as the last 100 days of the previously created “target” dataset.
Line 17 reorders the target dataset by dividing it by 5, and compares it to the prediction. You can then look at the two and see how they compare.
Since the “target” is not available for the last 5 days of the input, there is no prediction for those days. To predict for those days and later days, modify the dataset to the right of the askbcel command to have those additional; input days.
With FDC you can save this collection of commands as a “command set” and recall it any time you wish and run it simply by clicking on the autoplay icon. By doing so you can automatically retrain the neural network on the latest data. You can also change any of the parameters until you get the most appropriate neural net.