Index: /branches/3022-FastFunctionExtraction/FFX/Approach.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/FFX/Approach.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/FFX/Approach.cs	(revision 17779)
@@ -4,37 +4,35 @@
 namespace HeuristicLab.Algorithms.DataAnalysis.FastFunctionExtraction {
     internal struct Approach {
-        public bool AllowInter { get; set; }
-        public bool AllowDenom { get; set; }
+        public bool AllowInteractions { get; set; }
+        public bool AllowDenominators { get; set; }
         public bool AllowExp { get; set; }
-        public bool AllowNonlinFuncs { get; set; }
+        public bool AllowNonLinearFunctions { get; set; }
         public bool AllowHinge { get; set; }
         public HashSet<double> Exponents { get; set; }
-        public HashSet<NonlinearOperator> NonlinFuncs { get; set; }
-        public double MinHingeThr { get; set; }
-        public double MaxHingeThr { get; set; }
-        public int NumHingeThrs { get; set; }
-        public double ElnetPenalty { get; set; }
+        public HashSet<NonlinearOperator> NonLinearFunctions { get; set; }
+        public double MinHingeThreshold { get; set; }
+        public double MaxHingeThreshold { get; set; }
+        public int NumHingeThresholds { get; set; }
+        public double ElasticNetPenalty { get; set; }
         public int MaxNumBases { get; set; }
 
-        private static int Int(bool b) => b ? 1 : 0;
-
         public override string ToString() {
-            return $"Inter{Int(AllowInter)} Denom{Int(AllowDenom)} Exp{Int((AllowExp))} Nonlin{Int(AllowNonlinFuncs)} Hinge{Int(AllowHinge)}";
+            return $"Interactions{AllowInteractions} Denominator{AllowDenominators} Exponential{AllowExp} NonLinearFunctions{AllowNonLinearFunctions} HingeFunctions{AllowHinge}";
         }
 
-        public Approach(bool inter, bool denom, bool exp, bool nonlin, bool hinge, HashSet<double> exponents, HashSet<NonlinearOperator> nonlinFuncs, int maxNumBases, double penalty, double minHingeThr, double maxHingeThr, int numHingeThrs) {
-            this.AllowInter = inter;
-            this.AllowDenom = denom;
-            this.AllowExp = exp;
-            this.AllowNonlinFuncs = nonlin;
-            this.AllowHinge = hinge;
+        public Approach(bool allowInteractions, bool allowDenominators, bool allowExp, bool allowNonLinearFunctions, bool allowHingeFunctions, HashSet<double> exponents, HashSet<NonlinearOperator> nonLinearFunctions, int maxNumBases, double elasticNetPenality, double minHingeThreshold, double maxHingeThreshold, int numHingeThresholds) {
+            this.AllowInteractions = allowInteractions;
+            this.AllowDenominators = allowDenominators;
+            this.AllowExp = allowExp;
+            this.AllowNonLinearFunctions = allowNonLinearFunctions;
+            this.AllowHinge = allowHingeFunctions;
             if (AllowExp && exponents == null) throw new ArgumentNullException(nameof(exponents));
             Exponents = exponents;
-            if (AllowNonlinFuncs && nonlinFuncs == null) throw new ArgumentNullException(nameof(nonlinFuncs));
-            NonlinFuncs = nonlinFuncs;
-            MinHingeThr = minHingeThr;
-            MaxHingeThr = maxHingeThr;
-            NumHingeThrs = numHingeThrs;
-            ElnetPenalty = penalty;
+            if (AllowNonLinearFunctions && nonLinearFunctions == null) throw new ArgumentNullException(nameof(nonLinearFunctions));
+            NonLinearFunctions = nonLinearFunctions;
+            MinHingeThreshold = minHingeThreshold;
+            MaxHingeThreshold = maxHingeThreshold;
+            NumHingeThresholds = numHingeThresholds;
+            ElasticNetPenalty = elasticNetPenality;
             MaxNumBases = maxNumBases;
         }
Index: /branches/3022-FastFunctionExtraction/FFX/BFUtils.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/FFX/BFUtils.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/FFX/BFUtils.cs	(revision 17779)
@@ -14,5 +14,5 @@
         public static IEnumerable<IBasisFunction> CreateBasisFunctions(IRegressionProblemData data, Approach approach) {
             var exponents = approach.AllowExp ? approach.Exponents : new HashSet<double> { 1 };
-            var funcs = approach.AllowNonlinFuncs ? approach.NonlinFuncs : new HashSet<NonlinearOperator> { NonlinearOperator.None };
+            var funcs = approach.AllowNonLinearFunctions ? approach.NonLinearFunctions : new HashSet<NonlinearOperator> { NonlinearOperator.None };
             var simpleBasisFuncs = CreateSimpleBases(data, exponents, funcs);
 
@@ -20,15 +20,15 @@
                 // only allow hinge functions for features with exponent = 1 (deemed too complex otherwise)
                 var linearSimpleBasisFuncs = simpleBasisFuncs.Where(simpleBf => simpleBf.Exponent == 1 && simpleBf.Operator.Equals(NonlinearOperator.None));
-                simpleBasisFuncs = simpleBasisFuncs.Concat(CreateHingeBases(data, linearSimpleBasisFuncs, approach.MinHingeThr, approach.MaxHingeThr, approach.NumHingeThrs));
+                simpleBasisFuncs = simpleBasisFuncs.Concat(CreateHingeBases(data, linearSimpleBasisFuncs, approach.MinHingeThreshold, approach.MaxHingeThreshold, approach.NumHingeThresholds));
             }
 
             IEnumerable<IBasisFunction> functions = simpleBasisFuncs;
 
-            if (approach.AllowInter) {
+            if (approach.AllowInteractions) {
                 var multivariateBases = CreateMultivariateBases(data, simpleBasisFuncs.ToArray());
                 functions = functions.Concat(multivariateBases);
             }
 
-            if (approach.AllowDenom) {
+            if (approach.AllowDenominators) {
                 var denominatorBases = CreateDenominatorBases(functions);
                 functions = functions.Concat(denominatorBases);
@@ -37,5 +37,5 @@
         }
 
-        public static IEnumerable<ISimpleBasisFunction> CreateSimpleBases(IRegressionProblemData problemData, HashSet<double> exponents, HashSet<NonlinearOperator> nonlinFuncs) {
+        public static IEnumerable<ISimpleBasisFunction> CreateSimpleBases(IRegressionProblemData problemData, HashSet<double> exponents, HashSet<NonlinearOperator> nonLinearFunctions) {
             var simpleBasisFunctions = new List<ISimpleBasisFunction>();
             foreach (var variableName in problemData.AllowedInputVariables) {
@@ -45,13 +45,13 @@
                     var simpleBase = new SimpleBasisFunction(variableName, exp, NonlinearOperator.None);
                     // if the basis function is not valid without any operator, then it won't be valid in combination with any nonlinear operator -> skip
-                    if (!Ok(simpleBase.Simulate(problemData))) continue;
-
-                    foreach (NonlinearOperator op in nonlinFuncs) {
+                    if (!Ok(simpleBase.Evaluate(problemData))) continue;
+
+                    foreach (NonlinearOperator op in nonLinearFunctions) {
                         // ignore cases where op has no effect
-                        if (op.Equals(NonlinearOperator.Abs) && new[] { -2.0, 2.0 }.Contains(exp) && nonlinFuncs.Contains(NonlinearOperator.None)) continue;
+                        if (op.Equals(NonlinearOperator.Abs) && new[] { -2.0, 2.0 }.Contains(exp) && nonLinearFunctions.Contains(NonlinearOperator.None)) continue;
                         if (op.Equals(NonlinearOperator.Abs) && min >= 0) continue;
                         var nonsimpleBase = (SimpleBasisFunction)simpleBase.DeepCopy();
                         nonsimpleBase.Operator = op;
-                        if (!Ok(nonsimpleBase.Simulate(problemData))) continue;
+                        if (!Ok(nonsimpleBase.Evaluate(problemData))) continue;
                         simpleBasisFunctions.Add(nonsimpleBase);
                     }
@@ -77,5 +77,5 @@
                     if (b_j.Operator != NonlinearOperator.None) continue; // disallow op() * op(); deemed to complex
                     var b_inter = new ProductBaseFunction(b_i, b_j, true);
-                    if (!Ok(b_inter.Simulate(data))) continue;
+                    if (!Ok(b_inter.Evaluate(data))) continue;
                     multivariateBases.Add(b_inter);
                     if (multivariateBases.Count() >= maxSize)
@@ -98,5 +98,6 @@
         }
 
-        public static IList<ISimpleBasisFunction> CreateHingeBases(IRegressionProblemData data, IEnumerable<ISimpleBasisFunction> simple_bfs, double relative_start_thr = 0.0, double relative_end_thr = 1.0, int num_thrs = 3, IntRange trainingPartition = null) {
+        public static IList<ISimpleBasisFunction> CreateHingeBases(IRegressionProblemData data, IEnumerable<ISimpleBasisFunction> simple_bfs, 
+          double relative_start_thr = 0.0, double relative_end_thr = 1.0, int num_thrs = 3, IntRange trainingPartition = null) {
             var hingeBases = new List<ISimpleBasisFunction>();
 
@@ -107,9 +108,10 @@
         }
 
-        private static IEnumerable<ISimpleBasisFunction> CreateHingeBases(IRegressionProblemData data, ISimpleBasisFunction simple_bf, double relative_start_thr, double relative_end_thr, int num_thrs, IntRange trainingPartition) {
+        private static IEnumerable<ISimpleBasisFunction> CreateHingeBases(IRegressionProblemData data, ISimpleBasisFunction simple_bf, 
+          double relative_start_thr, double relative_end_thr, int num_thrs, IntRange trainingPartition) {
             if (relative_start_thr >= relative_end_thr) throw new ArgumentException($"{nameof(relative_start_thr)} must be smaller than {nameof(relative_end_thr)}.");
             var ans = new List<ISimpleBasisFunction>();
 
-            var vals = simple_bf.Simulate(data);
+            var vals = simple_bf.Evaluate(data);
             var temp = trainingPartition ?? data.TrainingPartition;
             double min = Double.MaxValue;
@@ -126,6 +128,6 @@
 
             foreach (var thr in thresholds) {
-                ans.Add(new SimpleBasisFunction(simple_bf.Feature, 1, NonlinearOperator.Gth, true, thr));
-                ans.Add(new SimpleBasisFunction(simple_bf.Feature, 1, NonlinearOperator.Lth, true, thr));
+                ans.Add(new SimpleBasisFunction(simple_bf.Feature, 1, NonlinearOperator.GT_Hinge, true, thr));
+                ans.Add(new SimpleBasisFunction(simple_bf.Feature, 1, NonlinearOperator.LT_Hinge, true, thr));
             }
             return ans;
@@ -135,7 +137,7 @@
             List<IBasisFunction> ans = new List<IBasisFunction>();
             foreach (var bf in basisFunctions) {
-                if (!bf.IsNominator) continue;
+                if (!bf.IsDenominator) continue;
                 var denomFunc = bf.DeepCopy();
-                denomFunc.IsNominator = false;
+                denomFunc.IsDenominator = false;
                 ans.Add(denomFunc);
             }
@@ -151,6 +153,6 @@
             int col = 0;
             foreach (var basisFunc in basisFunctions) {
-                allowedInputVars.Add(basisFunc.ToString() + (!basisFunc.IsNominator ? " * " + problemData.TargetVariable : ""));
-                var vals = basisFunc.Simulate(problemData);
+                allowedInputVars.Add(basisFunc.ToString() + (!basisFunc.IsDenominator ? " * " + problemData.TargetVariable : ""));
+                var vals = basisFunc.Evaluate(problemData);
                 for (int i = 0; i < numRows; i++) {
                     variableValues[i, col] = vals[i];
Index: /branches/3022-FastFunctionExtraction/FFX/FFXModel.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/FFX/FFXModel.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/FFX/FFXModel.cs	(revision 17779)
@@ -18,7 +18,7 @@
         public IEnumerable<(double coeff, IBasisFunction function)> BasisFunctions { get; set; }
         public IEnumerable<(double coeff, IBasisFunction function)> NominatorFunctions =>
-            BasisFunctions.Where(bf => bf.function.IsNominator);
+            BasisFunctions.Where(bf => bf.function.IsDenominator);
         public IEnumerable<(double coeff, IBasisFunction function)> DenominatorFunctions =>
-            BasisFunctions.Where(bf => !bf.function.IsNominator);
+            BasisFunctions.Where(bf => !bf.function.IsDenominator);
 
         public int NumNumeratorFunctions => NominatorFunctions != null ? NominatorFunctions.Count() : 0;
Index: /branches/3022-FastFunctionExtraction/FFX/FastFunctionExtraction.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/FFX/FastFunctionExtraction.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/FFX/FastFunctionExtraction.cs	(revision 17779)
@@ -12,11 +12,11 @@
 using System.Collections.Generic;
 using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using System.Collections;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.FastFunctionExtraction {
 
-    [Item(Name = "FastFunctionExtraction", Description = "An FFX algorithm.")]
+    [Item(Name = "FastFunctionExtraction", Description = "Implementation of the Fast Function Extraction (FFX) algorithm in C#.")]
     [Creatable(Category = CreatableAttribute.Categories.Algorithms, Priority = 999)]
-    [StorableType("689280F7-E371-44A2-98A5-FCEDF22CA343")] // for persistence (storing your algorithm to a files or transfer to HeuristicLab.Hive
+    [StorableType("689280F7-E371-44A2-98A5-FCEDF22CA343")]
     public sealed class FastFunctionExtraction : FixedDataAnalysisAlgorithm<IRegressionProblem> {
 
@@ -156,5 +156,5 @@
                 .SelectMany(approach => CreateFFXModels(data, approach)).ToList();
 
-            // Final pareto filter over all generated models from all different approaches
+            // Final Pareto filter over all generated models from all different approaches
             var nondominatedFFXModels = NondominatedModels(data, allFFXModels);
 
@@ -199,5 +199,5 @@
             var normalizedElnetData = BFUtils.Normalize(elnetData, out var X_avgs, out var X_stds, out var y_avg, out var y_std);
             
-            ElasticNetLinearRegression.RunElasticNetLinearRegression(normalizedElnetData, approach.ElnetPenalty, out var _, out var _, out var _, out var candidateCoeffsNorm, out var interceptNorm, maxVars: approach.MaxNumBases);
+            ElasticNetLinearRegression.RunElasticNetLinearRegression(normalizedElnetData, approach.ElasticNetPenalty, out var _, out var _, out var _, out var candidateCoeffsNorm, out var interceptNorm, maxVars: approach.MaxNumBases);
 
             var coefs = RebiasCoefs(candidateCoeffsNorm, interceptNorm, X_avgs, X_stds, y_avg, y_std, out var intercept);
@@ -251,5 +251,5 @@
 
             // return true if ALL indices of true values of arr1 also have true values in arr2
-            bool follows(bool[] arr1, bool[] arr2) {
+            bool follows(BitArray arr1, bool[] arr2) {
                 if (arr1.Length != arr2.Length) throw new ArgumentException("invalid lengths");
                 for (int i = 0; i < arr1.Length; i++) {
@@ -259,10 +259,15 @@
             }
 
+
             for (int i = 0; i < 32; i++) { // Iterate all combinations of 5 bools.
-                // map i to a bool array of length 5
-                var arr = i.ToBoolArray(5);
+                // map i to a bool array of length 5                
+                var v = i;
+                int b = 0;
+                var arr = new BitArray(5);
+                var popCount = 0;
+                while (v>0) { if (v % 2 == 1) { arr[b++] = true; popCount++; } ; v /= 2; }
+
                 if (!follows(arr, valids)) continue;
-                int sum = arr.Where(b => b).Count(); // how many features are enabled?
-                if (sum >= 4) continue; // not too many features at once
+                if (popCount >= 4) continue; // not too many features at once
                 if (arr[0] && arr[2]) continue; // never need both exponent and inter
                 approaches.Add(new Approach(arr[0], arr[1], arr[2], arr[3], arr[4], exponents, nonlinFuncs, maxNumBases, penalty, minHingeThr, maxHingeThr, numHingeThrs));
Index: /branches/3022-FastFunctionExtraction/FFX/IBasisFunction.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/FFX/IBasisFunction.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/FFX/IBasisFunction.cs	(revision 17779)
@@ -4,6 +4,6 @@
     internal interface IBasisFunction {
         int Complexity { get; }
-        bool IsNominator { get; set; }
-        double[] Simulate(IRegressionProblemData data);
+        bool IsDenominator { get; set; }
+        double[] Evaluate(IRegressionProblemData data);
         IBasisFunction DeepCopy();
     }
Index: /branches/3022-FastFunctionExtraction/FFX/NonlinearOperator.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/FFX/NonlinearOperator.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/FFX/NonlinearOperator.cs	(revision 17779)
@@ -2,5 +2,5 @@
 namespace HeuristicLab.Algorithms.DataAnalysis.FastFunctionExtraction {
     enum NonlinearOperator {
-        None, Abs, Log, Sin, Cos, Gth, Lth
+        None, Abs, Log, Sin, Cos, GT_Hinge, LT_Hinge
     }
 }
Index: /branches/3022-FastFunctionExtraction/FFX/Plugin.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/FFX/Plugin.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/FFX/Plugin.cs	(revision 17779)
@@ -5,10 +5,4 @@
   [PluginFile("HeuristicLab.Algorithms.DataAnalysis.FastFunctionExtraction.dll", PluginFileType.Assembly)] // each plugin represents a collection of files. The minimum is one file; the assembly.
 
-  // Usually your plugin references other HeuristicLab dlls. If you are referencing files (e.g. assemblies)
-  // from another plugin the corresponding plugin should be added as a dependency.
-  // Usually, if this information is incorrect you will still be able to use you plugin, but HL functionality
-  // which uses plugin dependency resolution will not work correctly. For instance if plugin dependencies are
-  // not correct then your plugin cannot be used on HeuristicLab.Hive
-  // 
   [PluginDependency("HeuristicLab.Algorithms.DataAnalysis", "3.4")]
   [PluginDependency("HeuristicLab.Algorithms.DataAnalysis.Glmnet", "3.4")]
@@ -28,25 +22,4 @@
   [PluginDependency("HeuristicLab.Random", "3.3")]
 
-  // HL plugin infrastructure discovers plugins on startup by trying to load all .dll and .exe files and looking for 
-  // classes deriving from PluginBase. The meta-information for the plugin class is specified in the attributes
-  // above, and used by plugin infrastructure primarily for plugin dependency resolution.
-
-  // Steps:
-  // (1) Check out HL source code (e.g. the trunk version)
-  // (2) Build external libraries HeuristicLab.ExtLibs.sln using the Build.cmd (in the path of the HL source code)
-  // (3) Build HeuristicLab 3.3.sln using the Build.cmd
-  // (4) Build this project. The output path for binaries is set to "".
-  //     this assumes you have the following folder structure
-  //    <ROOT>
-  //    |..hl
-  //       |..branches
-  //       |  |..Templates
-  //       |     |..EmptyPlugin
-  //       |..trunk
-  //          |.. bin 
-
-  //  (5) Check that the output file has been added to the HL binaries folder (hl/trunk/bin/EmptyPlugin.dll)
-  //  (6) Start hl/trunk/bin/HeuristicLab.exe and open the "Plugin Manager".
-  //      Make sure your EmptyPlugin appears in the list of loaded plugins 
   public class Plugin : PluginBase {
   }
Index: /branches/3022-FastFunctionExtraction/FFX/ProductBaseFunction.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/FFX/ProductBaseFunction.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/FFX/ProductBaseFunction.cs	(revision 17779)
@@ -8,17 +8,16 @@
         public IBasisFunction B2 { get; set; }
 
-        public int Complexity
-            => 1 + B1.Complexity + B2.Complexity;
+        public int Complexity => 1 + B1.Complexity + B2.Complexity;
 
-        public bool IsNominator { get; set; }
+        public bool IsDenominator { get; set; }
 
-        public ProductBaseFunction(IBasisFunction b1, IBasisFunction b2, bool nominator) {
+        public ProductBaseFunction(IBasisFunction b1, IBasisFunction b2, bool isDenominator) {
             B1 = b1 ?? throw new ArgumentNullException(nameof(b1));
             B2 = b2 ?? throw new ArgumentNullException(nameof(b2));
-            IsNominator = nominator;
+            IsDenominator = isDenominator;
         }
 
-        public double[] Simulate(IRegressionProblemData data) {
-            return B1.Simulate(data).Zip(B2.Simulate(data), (a, b) => a * b).ToArray();
+        public double[] Evaluate(IRegressionProblemData data) {
+            return B1.Evaluate(data).Zip(B2.Evaluate(data), (a, b) => a * b).ToArray();
         }
 
@@ -28,5 +27,5 @@
 
         public IBasisFunction DeepCopy() {
-            return new ProductBaseFunction(B1, B2, IsNominator);
+            return new ProductBaseFunction(B1, B2, IsDenominator);
         }
     }
Index: /branches/3022-FastFunctionExtraction/FFX/SimpleBasisFunction.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/FFX/SimpleBasisFunction.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/FFX/SimpleBasisFunction.cs	(revision 17779)
@@ -11,21 +11,21 @@
         public double Exponent { get; set; }
         public NonlinearOperator Operator { get; set; }
-        public bool IsNominator { get; set; }
+        public bool IsDenominator { get; set; }
         public string Feature { get; set; }
         public double Threshold { get; set; } // only relevant for hinge function 
-        public bool HasExponent => !Exponent.IsAlmost(1.0);
+        public bool HasExponent => !(Exponent == 1.0);
         public bool HasOperator => Operator != NonlinearOperator.None;
-        public int Complexity => Operator == NonlinearOperator.Gth || Operator == NonlinearOperator.Lth ? 3 : 1;
+        public int Complexity => Operator == NonlinearOperator.GT_Hinge || Operator == NonlinearOperator.LT_Hinge ? 3 : 1;
 
-        public SimpleBasisFunction(string feature, double exponent = 1, NonlinearOperator op = NonlinearOperator.None, bool isNominator = true, double thr = 0) {
+        public SimpleBasisFunction(string feature, double exponent = 1, NonlinearOperator op = NonlinearOperator.None, bool isNominator = true, double threshold = 0) {
             Feature = feature ?? throw new ArgumentNullException(nameof(feature));
             Exponent = exponent;
             Operator = op;
-            IsNominator = isNominator;
-            Threshold = thr;
+            IsDenominator = isNominator;
+            Threshold = threshold;
         }
 
         public IBasisFunction DeepCopy() {
-            return new SimpleBasisFunction(Feature, Exponent, Operator, IsNominator, Threshold);
+            return new SimpleBasisFunction(Feature, Exponent, Operator, IsDenominator, Threshold);
         }
 
@@ -46,8 +46,8 @@
 
             var thr = Threshold.ToString(culture);
-            if (Operator == NonlinearOperator.Lth) {
+            if (Operator == NonlinearOperator.LT_Hinge) {
                 var expr = $"{str} {((Threshold >= 0) ? " - " + Math.Abs(Threshold).ToString(culture) : " + " + Math.Abs(Threshold).ToString(culture))}";
                 str = $"IF(GT(0, {expr}), 0, {expr})";
-            } else if (Operator == NonlinearOperator.Gth) {
+            } else if (Operator == NonlinearOperator.GT_Hinge) {
                 var expr = $"{thr} - {str}";
                 str = $"IF(GT(0, {expr}), 0, {expr})";
@@ -58,5 +58,5 @@
         }
 
-        public double[] Simulate(IRegressionProblemData data) {
+        public double[] Evaluate(IRegressionProblemData data) {
             var exp = Exponent;
             // exponentVals : e.g. "x3^2"
@@ -67,5 +67,5 @@
             var vals = Eval(exponentVals);
 
-            if (!IsNominator) {
+            if (!IsDenominator) {
                 var y = data.TargetVariableValues;
                 vals = vals.Zip(y, (a, b) => -a * b).ToArray();
@@ -87,7 +87,7 @@
                 case NonlinearOperator.Cos:
                     return x.Select(val => Math.Cos(val)).ToArray();
-                case NonlinearOperator.Gth:
+                case NonlinearOperator.GT_Hinge:
                     return x.Select(val => Math.Max(0, thr - val)).ToArray();
-                case NonlinearOperator.Lth:
+                case NonlinearOperator.LT_Hinge:
                     return x.Select(val => Math.Max(0, val - thr)).ToArray();
                 default:
Index: /branches/3022-FastFunctionExtraction/FFX/Utils.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/FFX/Utils.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/FFX/Utils.cs	(revision 17779)
@@ -25,5 +25,4 @@
         }
 
-        // find the array containing n (linearly) evenly spaced double values ranging from start to end (including both)
         public static IEnumerable<double> Linspace(double start, double end, int n) {
             if (end < start) throw new ArgumentException("end must be higher that start");
@@ -35,37 +34,21 @@
 
         public static double[] Normalize(double[] vals)
-            => Bias(vals, 0, 1);
+            => Transform(vals, mean: 0, stdDev: 1);
 
-        public static double[] Bias(double[] vals, double targetAvg, double targetStd) {
+        public static double[] Transform(double[] vals, double mean, double stdDev) {
             var result = new double[vals.Length];
 
-            // bias standard deviation
-            var stdRatio = vals.StandardDeviationPop() / targetStd;
+            var scale = vals.StandardDeviationPop() / stdDev;
             for (int i = 0; i < vals.Length; i++) {
-                result[i] = vals[i] / stdRatio;
+                result[i] = vals[i] / scale;
             }
 
-            // bias average
-            var avgDiff = result.Average() - targetAvg;
+            var offset = result.Average() - mean;
             for (int i = 0; i < vals.Length; i++) {
-                result[i] = result[i] - avgDiff;
+                result[i] = result[i] - offset;
             }
 
             return result;
         }
-
-        public static bool[] ToBoolArray(this int val, int min_length) {
-            var temp = Convert.ToString(val, 2).Select(s => s.Equals('1')).ToArray();
-            if (temp.Length >= min_length) return temp;
-
-            var ans = new bool[min_length];
-            for(int i = 0; i < min_length - temp.Length; i++) {
-                ans[i] = false;
-            }
-            for(int i = 0; i < temp.Length; i++) {
-                ans[i + min_length - temp.Length] = temp[i];
-            }
-            return ans;
-        }
     }
 }
Index: /branches/3022-FastFunctionExtraction/UnitTests/BasisFunctionUtilsTests.cs
===================================================================
--- /branches/3022-FastFunctionExtraction/UnitTests/BasisFunctionUtilsTests.cs	(revision 17778)
+++ /branches/3022-FastFunctionExtraction/UnitTests/BasisFunctionUtilsTests.cs	(revision 17779)
@@ -117,5 +117,5 @@
                 Assert.AreEqual(hingeBase.Feature, "x3");
                 Assert.AreEqual(hingeBase.Exponent, 1);
-                Assert.AreEqual(hingeBase.IsNominator, true);
+                Assert.AreEqual(hingeBase.IsDenominator, true);
             }
         }
