Nice Idea  geektrader and i asked for that option before along with other options  See posts 21 ,22 and 23 , Here we become two persons asking for the same things 

That is an excellent idea. Unfortunately I cannot download the attached file since the only net access I have at the moment is via my AmazonKindle. It's good I can read the posts and can send a rospond, but it takes 20 minutes per post. Anyway, thank you Amazon for the free 3G worldwide.

Please ask fxwinner to send me the file.

As you proposed, the methods will be available for all the indicators.

Dear Popov
Happy that you liked my idea  for the smoothing logics , and regarding to the pdf file its only describe 3 out of the smoothing methods and i posted it as an example and if u like me to send you the materials regarding this topic which also include some MT4 indicators using these all smoothing method just send me your mail to send you all i have

regards
and keep the fantastic work

Yes, it's quite nice idea!

I wonder if there is "Noise Cutter" for all indicators, it'll be quite nice.
When you compare 2 previous values then judge "rising", "falling", "change direction", even the 2 values are almost the same, however the system will judge "up" or "down".
For example,
    Value1 = 20.13
    Value2 = 20.12
Then currently the system will judge "Value1 > Value2", right?
If you can set the percentage of noise-cut (how many percent of the noise you want to cut off), then as a result if the value is almost the same then the system will judge "Value1 = Value2". If you don't want to cut off anything, then you can simply set "0%".

How do you think? I'm not bright in programming, so I want to know other people's opinion.

Dear NicholasK  if i understand your words right , you mean that you need software logic to add specific value for the indicator before it take action  for example if indicator will rise you set the minimum % of rising value before it take the position !!!!  am i right

Hi ahmedalhoseny,

What I mean is not so complicated.
If the indicator judge "rising" or "falling", then it must be based on two values, right?
   Value1 > Value2 = "rising"
   Value1 < Value2 = "falling"
But if the those 2 values are almost the same amount, but the indicator will still judge "rising" or "falling".
for example
   Value1 = 13.1234
   Value2 = 13.1233
These 2 values are almost the same, however the indicator will judge it as "rising".

I wonder if you can set the percentage of neglect of these small difference at the parameter box in each indicator then the indicator will judge it as "Value1 = Value2". What I call "Noise Cut" is like this.
so if
   Value1 > Value2 + Value2 x ??%     then  "rising"
   Value1 < Value2 - Value2 x ??%      then "falling"
if
   Value2- Value2 x ??%   =<   Value1   =<   Value2 + Value2 x ??%        then "same"

So what i suggest is if there is IndParam.Num to set the percentage of this "noise cut" for each indicators, then it'll be nice.
But I don't know how to code it by myself, hahaha. So I ask people about this. I hope people can find better way of smoothing. krog gave some idea already

This is already included in FSB / FST for all logic rules.

It works automatically when you use base logic functions. For that case, the IndicatorRisesLogic function is used.

The code is:

        /// <summary>
        /// Returns signals for the logic rule "Indicator rises".
        /// </summary>
        protected void IndicatorRisesLogic(int iFirstBar, int iPrvs, double[] adIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
        {
            double dSigma = Sigma();

            for (int iBar = iFirstBar; iBar < Bars; iBar++)
            {
                int  iCurrBar  = iBar - iPrvs;
                int  iBaseBar  = iCurrBar - 1;
                bool bNoChange = true;
                bool bIsHigher = adIndValue[iCurrBar] > adIndValue[iBaseBar];

                while (Math.Abs(adIndValue[iCurrBar] - adIndValue[iBaseBar]) < dSigma && bNoChange && iBaseBar > iFirstBar)
                {
                    bNoChange = (bIsHigher == (adIndValue[iBaseBar + 1] > adIndValue[iBaseBar]));
                    iBaseBar--;
                }

                indCompLong.Value[iBar]  = adIndValue[iCurrBar] > adIndValue[iBaseBar] + dSigma ? 1 : 0;
                indCompShort.Value[iBar] = adIndValue[iCurrBar] < adIndValue[iBaseBar] - dSigma ? 1 : 0;
            }

            return;
        }

Where the acceptable error Sigma is:

        /// <summary>
        /// Maximum error for comparing indicator values
        /// </summary>
        protected double Sigma()
        {
            int iSigmaMode = isSeparatedChart ?
                Configs.SIGMA_MODE_SEPARATED_CHART : // Indicators plotted on its own chart (MACD, RSI, ADX, Momentum, ...)
                Configs.SIGMA_MODE_MAIN_CHART;       // Indicators plotted on the main chart (MA, Bollinger Bands, Alligator, ...)

            double dSigma;

            switch (iSigmaMode)
            {
                case 0:
                    dSigma = 0;
                    break;
                case 1:
                    dSigma = Data.InstrProperties.Point * 0.5;
                    break;
                case 2:
                    dSigma = Data.InstrProperties.Point * 0.05;
                    break;
                case 3:
                    dSigma = Data.InstrProperties.Point * 0.005;
                    break;
                case 4:
                    dSigma = 0.00005;
                    break;
                case 5:
                    dSigma = 0.000005;
                    break;
                case 6:
                    dSigma = 0.0000005;
                    break;
                case 7:
                    dSigma = 0.00000005;
                    break;
                case 8:
                    dSigma = 0.000000005;
                    break;
                default:
                    dSigma = 0;
                    break;
            }

            return dSigma;
        }

Where:

  <SIGMA_MODE_MAIN_CHART>1</SIGMA_MODE_MAIN_CHART>
  <SIGMA_MODE_SEPARATED_CHART>5</SIGMA_MODE_SEPARATED_CHART>

are set in the config file.

Is it possible to do some adjustments to Generator. Specifically, it would be useful if we could specify an indicator or set of indicators and then the Generator can search for optimal rules and parameters to create strategy from these indicators. I think currently this is not available.  I can lock for example MACD but only after I have specified the rule and parameters.

I have an idea will help us to best use generator and optimizer
1st the steps to generate strategy as follow:

1- select generator settings  and after finding a strategy
2- we use optimizer to optimize numerical settings only for indicators , and at that point what if we need to find more effecient points for entry and exit !!!!!!

3- we will block the optimized indicators pad and run the generator again to select more proper points for entry and exit  ( But what if the new strategy with the new entry and exit points not the profitable one using the same set of indicator !!!!!)  and the circle will continue ....... you got my point !!!

I think The best way to Make the optimization step is to make it a "Gen-optimization" process  so we can optimize ( Numerical values , indicators Logics and also the opening and closing points )

if this applicable it will be fantastic

Regards

Dear Popov

The optimizer is optional and we can select which part of strategy to optimize or not but having all strategy ingredients( numerical values , Logic values ,opening and closing points ) will make it more flexible
Another point to overcome this point ( to make the optimization a Walk-forward testing ) , and i think it will gives the flexibility without  over-opt  Is that possible !!!!
NB: i will send you a link to show you what i mean

Regards

I have an idea that the ideas being discussed in here are going to be addressed in the coming months by a substantial revision to the software which is in the very preliminary stages of design. The developer is attempting to develop a strategy builder which will reveal strategies that require far less in the way of optimization.

The idea is in a very preliminary stage and will take quite a while to implement.