Changeset 10702 for branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3

Timestamp:

04/02/14 13:02:17 (11 years ago)

Author:

tsteinre

Message:

refactored LinearTransformation / Transformation to fit HL coding style

Location:

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/Transformations

Files:

• LinearTransformation.cs (modified) (2 diffs)
• Transformation.cs (modified) (3 diffs)

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/Transformations/LinearTransformation.cs

@@ -21 +21 @@
 
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -28 +30 @@
 using HeuristicLab.DataPreprocessing.Transformations;
 using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 namespace HeuristicLab.DataPreprocessing.Implementations.Transformations {
   [Item("LinearTransformation", "Represents a linear transformation with multiplication and addition.")]
   public class LinearTransformation : Transformation<double> {
+    protected const string MultiplicandParameterName = "Multiplicand";
+    protected const string SummandParameterName = "Summand";
 
     #region Parameters
     public IValueParameter<DoubleValue> MultiplicandParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters["Multiplicand"]; }
+      get { return (IValueParameter<DoubleValue>)Parameters[MultiplicandParameterName]; }
     }
     public IValueParameter<DoubleValue> SummandParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters["Summand"]; }
+      get { return (IValueParameter<DoubleValue>)Parameters[SummandParameterName]; }
     }
     #endregion
 
-    public LinearTransformation()
-      : base() {
-      Parameters.Add(new ValueParameter<DoubleValue>("Multiplicand", "Multiplicand for linear transformation", new DoubleValue(1.0)));
-      Parameters.Add(new ValueParameter<DoubleValue>("Summand", "Summand for linear transformation", new DoubleValue(0.0)));
+    #region properties
+    public double Multiplicand {
+      get { return MultiplicandParameter.Value.Value; }
+    }
+
+    public double Summand {
+      get { return SummandParameter.Value.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected LinearTransformation(bool deserializing) : base(deserializing) { }
+    protected LinearTransformation(Transformation<double> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    protected LinearTransformation() {
+    }
+    public LinearTransformation(IEnumerable<string> allowedColumns)
+      : base(allowedColumns) {
+      Parameters.Add(new ValueParameter<DoubleValue>(MultiplicandParameterName, "Multiplicand for linear transformation", new DoubleValue(1.0)));
+      Parameters.Add(new ValueParameter<DoubleValue>(SummandParameterName, "Summand for linear transformation", new DoubleValue(0.0)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LinearTransformation(this, cloner);
     }
 
     public override IEnumerable<double> Apply(IEnumerable<double> data) {
-      return data.Select(e => e * MultiplicandParameter.Value.Value + SummandParameter.Value.Value).ToList();
+      return data.Select(e => e * Multiplicand + Summand);
     }
 
     public override IEnumerable<double> InverseApply(IEnumerable<double> data) {
-      throw new System.NotImplementedException();
+      return data.Select(e => (e - Summand) / Multiplicand);
     }
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      throw new System.NotImplementedException();
-    }
+    public override bool Check(IEnumerable<double> data, out string errorMsg) {
+      StringBuilder sb = new StringBuilder();
+      bool success = true;
+      errorMsg = null;
 
-    public override void Check(IEnumerable<double> data) {
-      throw new System.NotImplementedException();
+      if (Multiplicand == 0.0) {
+        sb.Append(String.Format("Multiplicand is 0, all {0} entries will be set to {1}. Reversal will not be possble", data.Count(), Summand));
+        errorMsg = sb.ToString();
+        success = false;
+      }
+      return success;
     }
   }

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/Transformations/Transformation.cs

@@ -21 +21 @@
 
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.DataAnalysis;
@@ -30 +33 @@
   [StorableClass]
   public abstract class Transformation<T> : ParameterizedNamedItem, ITransformation<T> {
-    public string Column { get; private set; }
+    protected const string ColumnParameterName = "Column";
+    #region parameter properties
+    public IConstrainedValueParameter<StringValue> ColumnParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters[ColumnParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public string Column {
+      get { return ColumnParameter.Value.Value; }
+    }
+    #endregion
 
     [StorableConstructor]
     protected Transformation(bool deserializing) : base(deserializing) { }
-    protected Transformation(Transformation<T> original, Cloner cloner)
-      : base(original, cloner) {
-      Column = original.Column;
-    }
+    protected Transformation(Transformation<T> original, Cloner cloner): base(original, cloner) {}
     protected Transformation() { }
-    protected Transformation(string column) {
-      this.Column = column;
+    protected Transformation(IEnumerable<string> allowedColumns) {
+      var allowed = new ItemSet<StringValue>(allowedColumns.Select(e => new StringValue(e)));
+      Parameters.Add(new ConstrainedValueParameter<StringValue>(ColumnParameterName, "Column used for the Transformation", allowed));
     }
 
@@ -47 +59 @@
     public abstract IEnumerable<T> InverseApply(IEnumerable<T> data);
 
-    public abstract void Check(IEnumerable<T> data);
+    public abstract bool Check(IEnumerable<T> data, out string errorMsg);
   }
 }