public override IGeneratorConf getConf(int CountFeatures)
        {
            IGeneratorConf result = new DynamicTuneConfGenerator();

            result.Init(CountFeatures);
            return(result);
        }
        public override TSAFuzzySystem Generate(TSAFuzzySystem Approximate, IGeneratorConf config)
        {
            TSAFuzzySystem result = Approximate;

            Pull_of_systems       = Pull_of_systems = new List <List <int> >();
            Systems_ready_to_test = new List <KnowlegeBaseTSARules>();
            errors_of_systems     = new List <double>();

            DynamicTuneConfGenerator config1 = config as DynamicTuneConfGenerator;

            type_func = config1.IEWOTypeFunc;



            List <int> Varians_of_run_system = new List <int>();


            List <int> allOne = new List <int>();

            for (int i = 0; i < Approximate.CountFeatures; i++)
            {
                allOne.Add(1);
            }
            Pull_of_systems.Add(new List <int>(allOne));

            for (int j = 0; j < Approximate.CountFeatures - 1; j++)
            {
                Varians_of_run_system.Clear();
                allOne[j] = 2;
                Varians_of_run_system.AddRange(new List <int> (allOne));
                Varians_of_run_system.Sort();
                Generate_all_variant_in_pool(Varians_of_run_system);
            }
            allOne[Approximate.CountFeatures - 1] = 2;
            Pull_of_systems.Add(new List <int> (allOne));

            for (int i = 0; i < Pull_of_systems.Count; i++)
            {
                Approximate.RulesDatabaseSet.Clear();

                GeneratorRulesEveryoneWithEveryone.InitRulesEveryoneWithEveryone(Approximate, type_func, Pull_of_systems[i].ToArray());
                Systems_ready_to_test.Add(Approximate.RulesDatabaseSet[0]);
                errors_of_systems.Add(result.approxLearnSamples(result.RulesDatabaseSet[0]));
            }

            DynamicTuneClass dt = new DynamicTuneClass();

            Approximate = dt.TuneUpFuzzySystem(Approximate, config1);
            Systems_ready_to_test.Add(Approximate.RulesDatabaseSet[0]);
            errors_of_systems.Add(result.approxLearnSamples(result.RulesDatabaseSet[0]));


            int best_index = errors_of_systems.IndexOf(errors_of_systems.Min());

            result.RulesDatabaseSet.Clear();
            result.RulesDatabaseSet.Add(Systems_ready_to_test[best_index]);
            count_slice_vars = new int[Approximate.CountFeatures];
            for (int i = 0; i < count_slice_vars.Count(); i++)
            {
                count_slice_vars[i] = result.RulesDatabaseSet[0].TermsSet.Count(x => x.NumVar == i);
            }
            maxError  = config1.MaxError;
            TryCount  = config1.TryCount;
            RuleCount = result.RulesDatabaseSet[0].RulesDatabase.Count;
            Console.WriteLine(Pull_of_systems.Count());
            result.RulesDatabaseSet[0].TermsSet.Trim();
            GC.Collect();

            return(result);
        }