Index: /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj
===================================================================
--- /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj	(revision 17540)
+++ /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj	(revision 17541)
@@ -262,4 +262,5 @@
     <Compile Include="Regression\VectorData\RandomExtensions.cs" />
     <Compile Include="Regression\VectorData\VectorDataInstanceProvider.cs" />
+    <Compile Include="Regression\VectorData\VectorDataTestTwo.cs" />
     <Compile Include="Regression\VectorData\VectorDataTestOne.cs" />
     <Compile Include="Regression\Vladislavleva\KotanchekFunction.cs" />
Index: /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataInstanceProvider.cs
===================================================================
--- /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataInstanceProvider.cs	(revision 17540)
+++ /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataInstanceProvider.cs	(revision 17541)
@@ -54,4 +54,8 @@
         new VectorDataTestOneC(rand.Next()),
         new VectorDataTestOneD(rand.Next()),
+        new VectorDataTestTwoA(rand.Next()),
+        new VectorDataTestTwoB(rand.Next()),
+        //new VectorDataTestTwoC(rand.Next()),
+        //new VectorDataTestTwoD(rand.Next()),
         new AzzaliBenchmark1(rand.Next()),
         new AzzaliBenchmark2(rand.Next()),
Index: /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataTestOne.cs
===================================================================
--- /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataTestOne.cs	(revision 17540)
+++ /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataTestOne.cs	(revision 17541)
@@ -25,5 +25,4 @@
 using System.Linq;
 using HeuristicLab.Core;
-using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Random;
 using MathNet.Numerics.Statistics;
@@ -32,5 +31,5 @@
 
 namespace HeuristicLab.Problems.Instances.DataAnalysis {
-  public abstract class VectorDataTestBase : ArtificialRegressionDataDescriptor {
+  public abstract class VectorDataTestOne : ArtificialRegressionDataDescriptor {
 
     protected const int Rows = 100;
@@ -48,7 +47,7 @@
     public int Seed { get; private set; }
 
-    protected VectorDataTestBase()
+    protected VectorDataTestOne()
       : this((int)DateTime.Now.Ticks) { }
-    protected VectorDataTestBase(int seed)
+    protected VectorDataTestOne(int seed)
       : base() {
       Seed = seed;
@@ -97,7 +96,7 @@
   }
 
-  public class VectorDataTestOneA : VectorDataTestBase {
+  public class VectorDataTestOneA : VectorDataTestOne {
     public override string Name {
-      get { return "Vector Data Test - I a (Y = X1 * sum(V1) + X2 * avg(V2)"; }
+      get { return "Vector Data Test - I [fully-constrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; }
     }
 
@@ -115,6 +114,6 @@
   }
 
-  public class VectorDataTestOneB : VectorDataTestBase {
-    public override string Name { get { return "Vector Data Test - I b (Y = X1 * sum(V1) + X2 * avg(V2)"; } }
+  public class VectorDataTestOneB : VectorDataTestOne {
+    public override string Name { get { return "Vector Data Test - I [row-constrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; } }
 
     public VectorDataTestOneB() : base() { }
@@ -131,6 +130,6 @@
   }
 
-  public class VectorDataTestOneC : VectorDataTestBase {
-    public override string Name { get { return "Vector Data Test - I c (Y = X1 * sum(V1) + X2 * avg(V2)"; } }
+  public class VectorDataTestOneC : VectorDataTestOne {
+    public override string Name { get { return "Vector Data Test - I [column-constrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; } }
 
     public VectorDataTestOneC() : base() { }
@@ -152,6 +151,6 @@
   }
 
-  public class VectorDataTestOneD : VectorDataTestBase {
-    public override string Name { get { return "Vector Data Test - I d (Y = X1 * sum(V1) + X2 * avg(V2)"; } }
+  public class VectorDataTestOneD : VectorDataTestOne {
+    public override string Name { get { return "Vector Data Test - I [unconstrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; } }
 
     public VectorDataTestOneD() : base() { }
Index: /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataTestTwo.cs
===================================================================
--- /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataTestTwo.cs	(revision 17541)
+++ /branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataTestTwo.cs	(revision 17541)
@@ -0,0 +1,167 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Random;
+using MathNet.Numerics.Statistics;
+
+using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public abstract class VectorDataTestTwo : ArtificialRegressionDataDescriptor {
+
+    protected const int Rows = 100;
+
+    public override string Description { get { return ""; } }
+
+    protected override string TargetVariable { get { return "Y"; } }
+    protected override string[] VariableNames { get { return new string[] { "X1", "X2", "X3", "V1", "V2", "Y" }; } }
+    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2", "X3", "V1", "V2" }; } }
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return Rows * 3 / 4; } }
+    protected override int TestPartitionStart { get { return TrainingPartitionEnd; } }
+    protected override int TestPartitionEnd { get { return Rows; } }
+
+    public int Seed { get; private set; }
+
+    protected VectorDataTestTwo()
+      : this((int)DateTime.Now.Ticks) { }
+    protected VectorDataTestTwo(int seed)
+      : base() {
+      Seed = seed;
+    }
+
+
+    protected override List<List<double>> GenerateValues() { return null; }
+    protected override List<IList> GenerateValuesExtended() {
+      var rand = new MersenneTwister((uint)Seed);
+
+      double x1, x2, x3;
+      DoubleVector v1, v2;
+      double y;
+
+      var x1Column = new List<double>(Rows);
+      var x2Column = new List<double>(Rows);
+      var x3Column = new List<double>(Rows);
+      var v1Column = new List<DoubleVector>(Rows);
+      var v2Column = new List<DoubleVector>(Rows);
+      var yColumn = new List<double>(Rows);
+
+      var vectorLengths = GetVectorLengths(rand);
+      for (int i = 0; i < Rows; i++) {
+        x1 = rand.NextDouble(-2, 2);
+        x2 = rand.NextDouble(2, 6);
+        x3 = rand.NextDouble(0, 1);
+        int v1Length = vectorLengths[0][i];
+        int v2Length = vectorLengths[1][i];
+        v1 = rand.NextDoubleVector(-2, 2, v1Length);
+        v2 = rand.NextDoubleVector(3, 5, v2Length);
+
+        y = x1 * v1.PointwiseExp().PointwiseMultiply(v2 + x2).Sum();
+
+        x1Column.Add(x1);
+        x2Column.Add(x2);
+        x3Column.Add(x3);
+        v1Column.Add(v1);
+        v2Column.Add(v2);
+        yColumn.Add(y);
+      }
+
+      return new List<IList> { x1Column, x2Column, x3Column, v1Column, v2Column, yColumn };
+    }
+
+    protected abstract List<int>[] GetVectorLengths(IRandom rand);
+  }
+
+  public class VectorDataTestTwoA : VectorDataTestTwo {
+    public override string Name {
+      get { return "Vector Data Test - II [fully-constrained]: Y = X1 * sum(exp(V1) * (V2 + X2))"; }
+    }
+
+    public VectorDataTestTwoA() : base() { }
+    public VectorDataTestTwoA(int seed) : base(seed) { }
+
+    protected override List<int>[] GetVectorLengths(IRandom rand) {
+      // always same length
+      const int length = 5;
+      return new List<int>[2] {
+        Enumerable.Repeat(length, Rows).ToList(),
+        Enumerable.Repeat(length, Rows).ToList()
+      };
+    }
+  }
+
+  public class VectorDataTestTwoB : VectorDataTestTwo {
+    public override string Name { get { return "Vector Data Test - II [row-constrained]: Y = X1 * mean(exp(V1) + X2 * V2)"; } }
+
+    public VectorDataTestTwoB() : base() { }
+    public VectorDataTestTwoB(int seed) : base(seed) { }
+
+    protected override List<int>[] GetVectorLengths(IRandom rand) {
+      // length between length 4 and 8, same row always the same length
+      var lengths = Enumerable.Range(0, Rows).Select(i => rand.Next(4, 8)).ToList();
+      return new List<int>[2] {
+        Enumerable.Range(0, Rows).Select(i => lengths[i]).ToList(),
+        Enumerable.Range(0, Rows).Select(i => lengths[i]).ToList()
+      };
+    }
+  }
+
+  //public class VectorDataTestTwoC : VectorDataTestTwo {
+  //  public override string Name { get { return "Vector Data Test - II [column-constrained]: Y = X1 * mean(exp(V1) + X2 * V2)"; } }
+
+  //  public VectorDataTestTwoC() : base() { }
+  //  public VectorDataTestTwoC(int seed) : base(seed) { }
+
+  //  protected override List<int>[] GetVectorLengths(IRandom rand) {
+  //    // length between length 4 and 8; each feature is same length
+  //    // force two different lengths
+  //    int v1Length = rand.Next(4, 8);
+  //    int v2Length;
+  //    do {
+  //      v2Length = rand.Next(4, 8);
+  //    } while (v1Length != v2Length);
+  //    return new List<int>[2] {
+  //      Enumerable.Repeat(v1Length, Rows).ToList(),
+  //      Enumerable.Repeat(v2Length, Rows).ToList()
+  //    };
+  //  }
+  //}
+
+  //public class VectorDataTestTwoD : VectorDataTestTwo {
+  //  public override string Name { get { return "Vector Data Test - II [unconstrained]: Y = X1 * mean(exp(V1) + X2 * V2)"; } }
+
+  //  public VectorDataTestTwoD() : base() { }
+  //  public VectorDataTestTwoD(int seed) : base(seed) { }
+
+  //  protected override List<int>[] GetVectorLengths(IRandom rand) {
+  //    // always random between 4 and 8
+  //    return new List<int>[2] {
+  //        Enumerable.Range(0, Rows).Select(i => rand.Next(4, 8)).ToList(),
+  //        Enumerable.Range(0, Rows).Select(i => rand.Next(4, 8)).ToList()
+  //      };
+  //  }
+  //}
+}
