Changeset 9226


Ignore:
Timestamp:
02/18/13 16:51:42 (5 years ago)
Author:
sforsten
Message:

#1980:

  • made classes in Problems.ConditionActionClassification abstract
  • added Problems.VariableVectorClassification and Problems.CombinedIntegerVectorClassification
  • LCS works now with arbitrary problems, which implement ConditionActionClassificationProblem
Location:
branches/LearningClassifierSystems
Files:
24 added
2 deleted
27 edited

Legend:

Unmodified
Added
Removed
  • branches/LearningClassifierSystems

    • Property svn:ignore
      •  

        old new  
        11*.suo
         2bin
  • branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs

    r9167 r9226  
    9595    }
    9696    #endregion
     97
     98    private CheckGASubsumptionOperator checkGASubsumptionOperator;
    9799
    98100    [StorableConstructor]
     
    155157      Assigner setSubsumpByAssigner = new Assigner();
    156158      Assigner setSubsumptionFalseAssigner = new Assigner();
    157       CheckGASubsumptionOperator checkGASubsumptionOperator = new CheckGASubsumptionOperator();
     159      checkGASubsumptionOperator = new CheckGASubsumptionOperator();
    158160      ConditionalBranch doGASubsumptionBranch2 = new ConditionalBranch();
    159161      ExecuteGASubsumptionOperator executeGAsubsumptionOperator = new ExecuteGASubsumptionOperator();
     
    199201      doGASubsumptionBranch1.ConditionParameter.ActualName = DoGASubsumptionParameter.ActualName;
    200202
    201       checkGASubsumptionOperator.ChildClassifiersParameter.ActualName = "CombinedIntegerVector";
    202       checkGASubsumptionOperator.ParentsClassifiersParameter.ActualName = "CombinedIntegerVector";
    203203      checkGASubsumptionOperator.NumerositiesParameter.ActualName = "Numerosity";
    204204      checkGASubsumptionOperator.ExperiencesParameter.ActualName = "Experience";
     
    283283      return base.Apply();
    284284    }
     285
     286    public void SetChildName(string childName) {
     287      checkGASubsumptionOperator.ChildClassifiersParameter.ActualName = childName;
     288      checkGASubsumptionOperator.ParentsClassifiersParameter.ActualName = childName;
     289    }
    285290  }
    286291}
  • branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs

    r9204 r9226  
    7979    private CoveringOperator covering;
    8080    private CountNumberOfUniqueActions countNumberOfUniqueActions;
     81    private MatchActionOperator matchActionOperator;
     82    private InsertInPopulationOperator insertInPopulation;
    8183
    8284    private LCSAdaptedGeneticAlgorithm adaptedGeneticAlgorithmMainLoop;
     
    130132      actionSelector = new ActionSelector();
    131133      UniformSubScopesProcessor matchActionSubScopesProcessor = new UniformSubScopesProcessor();
    132       MatchActionOperator matchActionOperator = new MatchActionOperator();
     134      matchActionOperator = new MatchActionOperator();
    133135      ConditionalSelector conditionMatchSelector = new ConditionalSelector();
    134136      ConditionalSelector actionMatchSelector = new ConditionalSelector();
     
    165167      UniformSubScopesProcessor setDeletionFalseSubScopeProcessor2 = new UniformSubScopesProcessor();
    166168      Assigner setDeletionFalseAssigner = new Assigner();
    167       InsertInPopulationOperator insertInPopulation = new InsertInPopulationOperator();
     169      insertInPopulation = new InsertInPopulationOperator();
    168170      XCSDeletionOperator deletionOperatorAfterGA = new XCSDeletionOperator();
    169171      ConditionalSelector deletionSelectorAfterGA = new ConditionalSelector();
     
    205207      iterationCounter.IncrementParameter.ActualName = "OneIntValue";
    206208
    207       matchConditionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
    208 
    209209      conditionMatchSelector.CopySelected = new BoolValue(false);
    210210      conditionMatchSelector.ConditionParameter.ActualName = matchConditionOperator.MatchConditionParameter.ActualName;
    211211
    212       countNumberOfUniqueActions.ClassifiersParameter.ActualName = "CombinedIntegerVector";
    213 
    214       doDeletionBeforeCovering.ClassifiersParameter.ActualName = "CombinedIntegerVector";
    215212      doDeletionBeforeCovering.MatchConditionParameter.ActualName = matchConditionOperator.MatchConditionParameter.ActualName;
    216213      doDeletionBeforeCovering.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
     
    242239      matchActionSubScopesProcessor.Operator = matchActionOperator;
    243240
    244       matchActionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
    245241      matchActionOperator.TargetMatchParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;
    246 
    247       predictionArrayCalculator.MatchParameter.ActualName = "CombinedIntegerVector";
    248242
    249243      actionSelector.PredictionArrayParameter.ActualName = predictionArrayCalculator.PredictionArrayParameter.Name;
     
    321315      currentPopulationSizeCounter.Increment = new IntValue(2);
    322316
    323       insertInPopulation.ClassifiersParameter.ActualName = "CombinedIntegerVector";
    324317      insertInPopulation.NumerositiesParameter.ActualName = "Numerosity";
    325318      insertInPopulation.HasToBeDeletedParameter.ActualName = HASTOBEDELETED;
     
    462455
    463456      countNumberOfUniqueActions.ClassifierComparerParameter.ActualName = problem.ClassifierComparerParameter.Name;
     457
     458      matchConditionOperator.MatchParameter.ActualName = problem.ChildName;
     459      countNumberOfUniqueActions.ClassifiersParameter.ActualName = problem.ChildName;
     460      doDeletionBeforeCovering.ClassifiersParameter.ActualName = problem.ChildName;
     461      matchActionOperator.MatchParameter.ActualName = problem.ChildName;
     462      predictionArrayCalculator.MatchParameter.ActualName = problem.ChildName;
     463      insertInPopulation.ClassifiersParameter.ActualName = problem.ChildName;
     464
     465      adaptedGeneticAlgorithmMainLoop.SetChildName(problem.ChildName);
    464466    }
    465467    //private void ParameterizeSelectors() {
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs

    r9194 r9226  
    2121
    2222using System;
    23 using System.Collections.Generic;
    2423using System.Linq;
    2524using System.Text;
     
    264263      return true;
    265264    }
    266 
    267     public override bool Equals(object obj) {
    268       return base.Equals(obj);
    269     }
    270 
    271     public override int GetHashCode() {
    272       return base.GetHashCode();
    273     }
    274 
    275     [StorableClass]
    276     [Item("CombinedIntegerVectorComparer", "")]
    277     public class CombinedIntegerVectorComparer : Item, IEqualityComparer<CombinedIntegerVector>, IClassifierComparer {
    278 
    279       [StorableConstructor]
    280       protected CombinedIntegerVectorComparer(bool deserializing) : base(deserializing) { }
    281       protected CombinedIntegerVectorComparer(CombinedIntegerVectorComparer original, Cloner cloner)
    282         : base(original, cloner) {
    283       }
    284       public override IDeepCloneable Clone(Cloner cloner) {
    285         return new CombinedIntegerVectorComparer(this, cloner);
    286       }
    287       public CombinedIntegerVectorComparer() : base() { }
    288 
    289       public bool Equals(CombinedIntegerVector x, CombinedIntegerVector y) {
    290         for (int i = 0; i < x.array.Length; i++) {
    291           if (!x.array[i].Equals(y.array[i])) {
    292             return false;
    293           }
    294         }
    295         return true;
    296       }
    297 
    298       public int GetHashCode(CombinedIntegerVector obj) {
    299         int result = obj.actionLength;
    300         for (int i = 0; i < obj.array.Length; i++) {
    301           result ^= obj.array[i];
    302         }
    303         return result.GetHashCode();
    304       }
    305 
    306       public bool Equals(IAction x, IAction y) {
    307         var xCast = x as CombinedIntegerVector;
    308         var yCast = y as CombinedIntegerVector;
    309         return x != null && y != null && Equals(xCast, yCast);
    310       }
    311 
    312       public int GetHashCode(IAction obj) {
    313         var objCast = obj as CombinedIntegerVector;
    314         return objCast != null ? GetHashCode(objCast) : obj.GetHashCode();
    315       }
    316     }
    317265  }
    318266}
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj

    r9194 r9226  
    121121  <ItemGroup>
    122122    <Compile Include="CombinedIntegerVector.cs" />
     123    <Compile Include="CombinedIntegerVectorComparer.cs" />
    123124    <Compile Include="CombinedIntegerVectorCreator.cs" />
    124125    <Compile Include="CombinedIntegerVectorCrossover.cs" />
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs

    r9204 r9226  
    2525namespace HeuristicLab.Encodings.ConditionActionEncoding {
    2626  public interface IConditionActionProblem : IHeuristicOptimizationProblem {
     27    string ChildName { get; }
     28
    2729    IParameter ProblemDataParameter { get; }
    2830    IConditionActionProblemData ProblemData { get; }
     
    3335    IParameter ThetaMinimalNumberOfActionsParameter { get; }
    3436
    35     IParameter PossibleActionsConcreteClassParameter { get; }
    3637    IParameter PossibleActionsParameter { get; }
    3738
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs

    r9204 r9226  
    2929using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    3030
    31 namespace HeuristicLab.Encodings.VariableVector.Covering {
     31namespace HeuristicLab.Encodings.VariableVector {
    3232  [Item("VariableVectorCoveringCreator", "Description missing")]
    3333  [StorableClass]
     
    6363    private IEnumerable<IVariable> CoverInput(VariableVectorInput input, VariableVectorCondition sample, IRandom random, double changeSymbolProbability) {
    6464      var conditionVariables = new List<IVariable>();
    65       if (!input.Order.SequenceEqual(sample.Order)) {
    66         throw new ArgumentException("Sample and input do not contain the same variable names");
     65      if (!sample.Keys.All(x => input.ContainsKey(x))) {
     66        throw new ArgumentException("Input does not contain all variable names from sample");
    6767      }
    6868      foreach (var keyValuePair in sample) {
    6969        IVariable variable = keyValuePair.Value.GetEmptyCopy();
    70         variable.Cover(random, input[keyValuePair.Key].Value, changeSymbolProbability);
     70        variable.Cover(random, input[keyValuePair.Key], changeSymbolProbability);
    7171        conditionVariables.Add(variable);
    7272      }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Creators/UniformRandomVariableVectorCreator.cs

    r9194 r9226  
    2020#endregion
    2121
    22 using System.Linq;
    2322using HeuristicLab.Common;
    2423using HeuristicLab.Core;
    2524using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2625
    27 namespace HeuristicLab.Encodings.VariableVector.Creators {
     26namespace HeuristicLab.Encodings.VariableVector {
    2827  [Item("UniformRandomVariableVectorCreator", "Description missing")]
    2928  [StorableClass]
     
    4645
    4746    protected override VariableVector Create(IRandom random, VariableVector sampleVariableVector, double spreadPercentage) {
    48       var result = new VariableVector(sampleVariableVector.Condition.Values.Select(x => x.GetEmptyCopy()), sampleVariableVector.Action.Values.Select(x => x.GetEmptyCopy()));
     47      var result = sampleVariableVector.GetEmptyCopy();
    4948      result.Randomize(random, spreadPercentage);
    5049      return result;
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs

    r9204 r9226  
    2727using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2828
    29 namespace HeuristicLab.Encodings.VariableVector.Crossover {
     29namespace HeuristicLab.Encodings.VariableVector {
    3030  [Item("SinglePointCrossover", "Description missing")]
    3131  [StorableClass]
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj

    r9204 r9226  
    4444      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
    4545    </Reference>
     46    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
    4647    <Reference Include="HeuristicLab.Data-3.3">
    4748      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
     
    6465    <Reference Include="System" />
    6566    <Reference Include="System.Core" />
     67    <Reference Include="System.Drawing" />
    6668    <Reference Include="System.Xml.Linq" />
    6769    <Reference Include="System.Data.DataSetExtensions" />
     
    7981    <Compile Include="Manipulator\UniformOnePositionInConditionManipulator.cs" />
    8082    <Compile Include="Manipulator\UniformSomePositionManipulator.cs" />
     83    <Compile Include="VariableVectorActionComparer.cs" />
    8184    <Compile Include="VariableVectorCrossover.cs" />
    8285    <Compile Include="VariableVectorManipulator.cs" />
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs

    r9204 r9226  
    5656      var keyEnumerator = condition.Order.GetEnumerator();
    5757      int count = 0;
    58       while (keyEnumerator.MoveNext() && count < condition.VirtualLength
    59         && count < index && count + condition[keyEnumerator.Current].VirtualLength < index) {
     58      keyEnumerator.MoveNext();
     59      while (count < condition.VirtualLength && count < index && count + condition[keyEnumerator.Current].VirtualLength <= index) {
    6060        count += condition[keyEnumerator.Current].VirtualLength;
     61        keyEnumerator.MoveNext();
    6162      }
    62       condition[keyEnumerator.Current].Manipulate(random, input[keyEnumerator.Current].Value, index - count - 1);
     63      condition[keyEnumerator.Current].Manipulate(random, input[keyEnumerator.Current], index - count);
    6364      return child;
    6465    }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Plugin.cs

    r9204 r9226  
    2323
    2424namespace HeuristicLab.Encodings.VariableVector {
    25   [Plugin("HeuristicLab.Encodings.VariableVector", "3.3.7.9194")]
     25  [Plugin("HeuristicLab.Encodings.VariableVector", "3.3.7.9204")]
    2626  [PluginFile("HeuristicLab.Encodings.VariableVector-3.3.dll", PluginFileType.Assembly)]
    2727  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Properties/AssemblyInfo.cs

    r9204 r9226  
    5555// [assembly: AssemblyVersion("1.0.*")]
    5656[assembly: AssemblyVersion("3.3.0.0")]
    57 [assembly: AssemblyFileVersion("3.3.7.9194")]
     57[assembly: AssemblyFileVersion("3.3.7.9204")]
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs

    r9204 r9226  
    100100    }
    101101
    102     public new DoubleVariable GetEmptyCopy() {
     102    public override IVariable GetEmptyCopy() {
    103103      return new DoubleVariable(variableName, min, max);
    104104    }
    105     public new DoubleVariable GetSetCopy() {
    106       DoubleVariable copy = GetEmptyCopy();
     105    public override IVariable GetSetCopy() {
     106      DoubleVariable copy = (DoubleVariable)GetEmptyCopy();
    107107      copy.CurrentCenter = this.CurrentCenter;
    108108      copy.CurrentSpread = this.CurrentSpread;
     
    153153      if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
    154154      if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
    155       DoubleVariable crossed = this.GetSetCopy();
     155      DoubleVariable crossed = (DoubleVariable)this.GetSetCopy();
    156156      if (pos == 0) {
    157157        crossed.CurrentSpread = parent2Cast.CurrentSpread;
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IActionVariable.cs

    r9194 r9226  
    2020#endregion
    2121
     22using System.Collections.Generic;
    2223
    2324namespace HeuristicLab.Encodings.VariableVector {
    2425  // variables which can be used in the action
    2526  public interface IActionVariable : IVariable {
     27    new IActionVariable GetEmptyCopy();
     28    new IActionVariable GetSetCopy();
     29
     30    void SetTo(string value);
     31    IEnumerable<string> GetAllPossibleActions();
    2632  }
    2733}
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs

    r9204 r9226  
    3131    IVariable GetEmptyCopy();
    3232    IVariable GetSetCopy();
     33
    3334    void Randomize(IRandom random);
    3435    bool MatchInput(string target);
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs

    r9204 r9226  
    6363      this.possibleFeatures = new List<int>(original.possibleFeatures);
    6464      this.Wildcard = original.Wildcard;
     65      this.currentValue = original.currentValue;
    6566    }
    6667    public IntVariable()
     
    7071    public IntVariable(string variableName, IEnumerable<int> variableValues)
    7172      : base(variableName) {
    72       if (variableValues.Count() != variableValues.Distinct().Count()) {
    73         throw new ArgumentException("variableValues have to be distinct.");
     73      if (variableValues.Count() > 0 && variableValues.Count() != variableValues.Distinct().Count()) {
     74        throw new ArgumentException("variableValues have to be distinct and there has to be at least one value.");
    7475      }
    7576      possibleFeatures = variableValues;
    7677      Wildcard = false;
     78      currentValue = possibleFeatures.First();
    7779    }
    7880    public IntVariable(string variableName, IEnumerable<int> variableValues, int currentValue)
     
    102104    }
    103105
    104     public new IntVariable GetEmptyCopy() {
     106    public override IVariable GetEmptyCopy() {
    105107      return new IntVariable(variableName, possibleFeatures);
    106108    }
    107     public new IntVariable GetSetCopy() {
    108       IntVariable copy = GetEmptyCopy();
     109
     110    public override IVariable GetSetCopy() {
     111      IntVariable copy = (IntVariable)GetEmptyCopy();
    109112      copy.Wildcard = this.Wildcard;
    110113      copy.CurrentValue = this.CurrentValue;
    111114      return copy;
     115    }
     116
     117    IActionVariable IActionVariable.GetEmptyCopy() {
     118      return (IntVariable)GetEmptyCopy();
     119    }
     120    IActionVariable IActionVariable.GetSetCopy() {
     121      return (IntVariable)GetSetCopy();
    112122    }
    113123
     
    143153      if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
    144154      if (pos != 0) { throw new ArgumentOutOfRangeException(); }
    145       return this.GetSetCopy();
     155      return (IntVariable)this.GetSetCopy();
    146156    }
    147157
     
    160170      }
    161171    }
     172
     173    public override int GetHashCode() {
     174      int result = 1;
     175      int wildcardInt = Wildcard ? 1 : 0;
     176      result = 37 * result + wildcardInt;
     177      result = 37 * result + currentValue;
     178      foreach (var feature in possibleFeatures) {
     179        result = 37 * result + feature;
     180      }
     181      return result;
     182    }
     183
     184    #region IActionVariable Members
     185    public void SetTo(string value) {
     186      currentValue = int.Parse(value);
     187    }
     188
     189    public IEnumerable<string> GetAllPossibleActions() {
     190      return possibleFeatures.Select(x => x.ToString());
     191    }
     192    #endregion
    162193  }
    163194}
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs

    r9204 r9226  
    7474      this.featureMapping = new Dictionary<int, string>(original.featureMapping);
    7575      this.Wildcard = original.Wildcard;
     76      this.currentValue = original.currentValue;
    7677    }
    7778    public StringVariable()
     
    150151    }
    151152
    152     public new StringVariable GetEmptyCopy() {
     153    public override IVariable GetEmptyCopy() {
    153154      return new StringVariable(variableName, featureMapping);
    154155    }
    155     public new StringVariable GetSetCopy() {
    156       StringVariable copy = GetEmptyCopy();
     156    public override IVariable GetSetCopy() {
     157      StringVariable copy = (StringVariable)GetEmptyCopy();
    157158      copy.Wildcard = this.Wildcard;
    158159      copy.CurrentValue = this.CurrentValue;
    159160      return copy;
     161    }
     162    IActionVariable IActionVariable.GetEmptyCopy() {
     163      return (StringVariable)GetEmptyCopy();
     164    }
     165    IActionVariable IActionVariable.GetSetCopy() {
     166      return (StringVariable)GetSetCopy();
    160167    }
    161168
     
    195202      if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
    196203      if (pos != 0) { throw new ArgumentOutOfRangeException(); }
    197       return this.GetSetCopy();
     204      return (StringVariable)this.GetSetCopy();
    198205    }
    199206
     
    202209      Wildcard = !Wildcard;
    203210      if (!Wildcard) {
    204         int newValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
    205         currentValue = newValue;
     211        currentValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
    206212      }
    207213    }
     
    210216      Wildcard = random.NextDouble() < changeSymbolProbability;
    211217      if (!Wildcard) {
    212         int newValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
    213         currentValue = newValue;
    214       }
    215     }
     218        currentValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
     219      }
     220    }
     221
     222    public override int GetHashCode() {
     223      int result = 1;
     224      int wildcardInt = Wildcard ? 1 : 0;
     225      result = 37 * result + wildcardInt;
     226      result = 37 * result + currentValue;
     227      foreach (var feature in featureMapping) {
     228        result = 37 * result + feature.Key;
     229        result = 37 * result + feature.Value.GetHashCode();
     230      }
     231      return result;
     232    }
     233
     234    #region IActionVariable Members
     235    public void SetTo(string value) {
     236      currentValue = featureMapping.First(x => x.Value.Equals(value)).Key;
     237    }
     238
     239    public IEnumerable<string> GetAllPossibleActions() {
     240      return featureMapping.Values;
     241    }
     242    #endregion
    216243  }
    217244}
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs

    r9204 r9226  
    5252    }
    5353
    54     public virtual IVariable GetEmptyCopy() { throw new NotSupportedException("This method is not supported. It should be implemented by every non abstract class."); }
    55     public virtual IVariable GetSetCopy() { throw new NotSupportedException("This method is not supported. It should be implemented by every non abstract class."); }
     54    public abstract IVariable GetEmptyCopy();
     55    public abstract IVariable GetSetCopy();
    5656
    5757    public abstract void Randomize(IRandom random);
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs

    r9204 r9226  
    5454    protected VariableVector(VariableVector original, Cloner cloner)
    5555      : base(original, cloner) {
    56       condition = new VariableVectorCondition(original.condition);
    57       action = new VariableVectorAction(original.action);
     56      condition = (VariableVectorCondition)original.condition.Clone();
     57      action = (VariableVectorAction)original.action;
    5858    }
    5959    public VariableVector() {
     
    6464      : this() {
    6565      if (condition == null || action == null) { throw new ArgumentNullException(); }
    66       if (action.All(x => x is IActionVariable)) { throw new ArgumentException("Action can only use IActionVariable"); }
     66      if (!action.All(x => x is IActionVariable)) { throw new ArgumentException("Action can only use IActionVariable"); }
    6767      this.Condition.Add(condition);
    6868      this.Action.Add(action.Cast<IActionVariable>());
     
    7070    public override IDeepCloneable Clone(Cloner cloner) {
    7171      return new VariableVector(this, cloner);
     72    }
     73
     74    public VariableVector GetEmptyCopy() {
     75      return new VariableVector(Condition.Values.Select(x => x.GetEmptyCopy()), Action.Values.Select(x => x.GetEmptyCopy()));
    7276    }
    7377
     
    128132      var targetCast = target as VariableVector;
    129133      if (targetCast == null) { return false; }
    130       if (!condition.Identical(targetCast.condition)) { return false; }
    131       if (!action.Identical(targetCast.condition)) { return false; }
     134      if (!condition.Identical(targetCast.Condition)) { return false; }
     135      if (!action.Identical(targetCast.Action)) { return false; }
    132136      return true;
    133     }
    134 
    135     [StorableClass]
    136     [Item("VariableVectorActionComparer", "")]
    137     public class VariableVectorActionComparer : Item, IEqualityComparer<VariableVectorAction>, IClassifierComparer {
    138 
    139       [StorableConstructor]
    140       protected VariableVectorActionComparer(bool deserializing) : base(deserializing) { }
    141       protected VariableVectorActionComparer(VariableVectorActionComparer original, Cloner cloner)
    142         : base(original, cloner) {
    143       }
    144       public override IDeepCloneable Clone(Cloner cloner) {
    145         return new VariableVectorActionComparer(this, cloner);
    146       }
    147       public VariableVectorActionComparer() : base() { }
    148 
    149       public bool Equals(VariableVectorAction x, VariableVectorAction y) {
    150         throw new NotImplementedException();
    151       }
    152 
    153       public int GetHashCode(VariableVectorAction obj) {
    154         throw new NotImplementedException();
    155       }
    156 
    157       public bool Equals(IAction x, IAction y) {
    158         var xCast = x as VariableVectorAction;
    159         var yCast = y as VariableVectorAction;
    160         return x != null && y != null && Equals(xCast, yCast);
    161       }
    162 
    163       public int GetHashCode(IAction obj) {
    164         var objCast = obj as VariableVectorAction;
    165         return objCast != null ? GetHashCode(objCast) : obj.GetHashCode();
    166       }
    167137    }
    168138  }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs

    r9204 r9226  
    2222using System;
    2323using System.Collections.Generic;
     24using System.Drawing;
    2425using System.Linq;
    2526using System.Text;
    2627using HeuristicLab.Common;
    2728using HeuristicLab.Core;
    28 using HeuristicLab.Data;
    2929using HeuristicLab.Encodings.ConditionActionEncoding;
    3030using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     
    3333  [StorableClass]
    3434  [Item("VariableVectorAction", "")]
    35   public class VariableVectorAction : ItemDictionary<StringValue, IActionVariable>, IAction {
     35  public class VariableVectorAction : Dictionary<string, IActionVariable>, IAction {
    3636
    37     public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
     37    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
    3838
    3939    public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
    4040
    4141    [StorableConstructor]
    42     protected VariableVectorAction(bool deserializing) : base(deserializing) { }
    43     protected VariableVectorAction(VariableVectorAction original, Cloner cloner)
    44       : base(original, cloner) {
     42    protected VariableVectorAction(bool deserializing) { }
     43    protected VariableVectorAction(VariableVectorAction original, Cloner cloner) {
     44      foreach (var item in original) {
     45        Add((string)item.Key.Clone(), (IActionVariable)item.Value.Clone());
     46      }
    4547    }
    4648    public VariableVectorAction() : base() { }
    4749    public VariableVectorAction(int capacity) : base(capacity) { }
    48     public VariableVectorAction(IDictionary<StringValue, IActionVariable> dictionary) : base(dictionary) { }
    49     public override IDeepCloneable Clone(Cloner cloner) {
    50       return new VariableVectorAction(this, cloner);
     50    public VariableVectorAction(IDictionary<string, IActionVariable> dictionary) : base(dictionary) { }
     51
     52    //protected override void OnItemsAdded(IEnumerable<KeyValuePair<string, IActionVariable>> items) {
     53    //  foreach (var item in items) {
     54    //    if (!(item.Value is StringVariable || item.Value is IntVariable)) {
     55    //      throw new ArgumentException("Value has to be of type 'StringVariable' or 'IntVariable'");
     56    //    }
     57    //  }
     58    //}
     59
     60    public VariableVectorAction GetEmptyCopy() {
     61      VariableVectorAction emptyCopy = new VariableVectorAction(this.Count);
     62      foreach (var keyValuePair in this) {
     63        emptyCopy.Add(keyValuePair.Key, keyValuePair.Value.GetEmptyCopy());
     64      }
     65      return emptyCopy;
    5166    }
    5267
    53     protected override void OnItemsAdded(IEnumerable<KeyValuePair<StringValue, IActionVariable>> items) {
    54       foreach (var item in items) {
    55         if (!(item.Value is StringVariable || item.Value is IntVariable)) {
    56           throw new ArgumentException("Value has to be of type 'StringVariable' or 'IntVariable'");
    57         }
     68    public VariableVectorAction GetSetCopy() {
     69      VariableVectorAction setCopy = new VariableVectorAction(this.Count);
     70      foreach (var keyValuePair in this) {
     71        setCopy.Add(keyValuePair.Key, keyValuePair.Value.GetSetCopy());
    5872      }
    59       base.OnItemsAdded(items);
     73      return setCopy;
    6074    }
    6175
     
    6377      var targetCast = target as VariableVectorAction;
    6478      if (targetCast == null) { return false; }
    65       if (this.Order.SequenceEqual(targetCast.Order)) { return false; }
     79      if (!this.Order.SequenceEqual(targetCast.Order)) { return false; }
    6680      foreach (var keyValuePair in targetCast) {
    6781        if (!this[keyValuePair.Key].MatchVariable(keyValuePair.Value)) {
     
    7488    public void Add(IEnumerable<IActionVariable> action) {
    7589      foreach (var variable in action) {
    76         this.Add(new StringValue(variable.VariableName), variable);
     90        this.Add(variable.VariableName, variable);
    7791      }
    7892    }
     
    8296      bool first = true;
    8397      foreach (var variable in this.Values) {
    84         if (!first) {
     98        if (first) {
    8599          first = false;
    86100        } else {
     
    98112    }
    99113
    100     public bool Identical(VariableVectorCondition target) {
     114    public bool Identical(VariableVectorAction target) {
    101115      if (this.Order.SequenceEqual(target.Order)) { return false; }
    102116      foreach (var keyValuePair in target) {
     
    107121      return true;
    108122    }
     123
     124    public virtual string ItemName {
     125      get { return ItemAttribute.GetName(this.GetType()); }
     126    }
     127    public virtual string ItemDescription {
     128      get { return ItemAttribute.GetDescription(this.GetType()); }
     129    }
     130    public Version ItemVersion {
     131      get { return ItemAttribute.GetVersion(this.GetType()); }
     132    }
     133    public static Image StaticItemImage {
     134      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
     135    }
     136    public virtual Image ItemImage {
     137      get { return ItemAttribute.GetImage(this.GetType()); }
     138    }
     139
     140    public virtual IDeepCloneable Clone(Cloner cloner) {
     141      return new VariableVectorAction(this, cloner);
     142    }
     143
     144    public object Clone() {
     145      return Clone(new Cloner());
     146    }
     147
     148    public event EventHandler ItemImageChanged;
     149    protected virtual void OnItemImageChanged() {
     150      EventHandler handler = ItemImageChanged;
     151      if (handler != null) handler(this, EventArgs.Empty);
     152    }
     153    public event EventHandler ToStringChanged;
     154    protected virtual void OnToStringChanged() {
     155      EventHandler handler = ToStringChanged;
     156      if (handler != null) handler(this, EventArgs.Empty);
     157    }
    109158  }
    110159}
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs

    r9204 r9226  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
     24using System.Drawing;
    2325using System.Linq;
    2426using System.Text;
    2527using HeuristicLab.Common;
    2628using HeuristicLab.Core;
    27 using HeuristicLab.Data;
    2829using HeuristicLab.Encodings.ConditionActionEncoding;
    2930using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     
    3233  [StorableClass]
    3334  [Item("VariableVectorCondition", "")]
    34   public class VariableVectorCondition : ItemDictionary<StringValue, IVariable>, ICondition {
     35  public class VariableVectorCondition : Dictionary<string, IVariable>, ICondition {
    3536
    36     public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
     37    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
    3738
    3839    public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
    3940
    4041    [StorableConstructor]
    41     protected VariableVectorCondition(bool deserializing) : base(deserializing) { }
    42     protected VariableVectorCondition(VariableVectorCondition original, Cloner cloner)
    43       : base(original, cloner) {
     42    protected VariableVectorCondition(bool deserializing) { }
     43    protected VariableVectorCondition(VariableVectorCondition original, Cloner cloner) {
     44      foreach (var item in original) {
     45        Add((string)item.Key.Clone(), (IVariable)item.Value.Clone());
     46      }
    4447    }
    4548    public VariableVectorCondition() : base() { }
    4649    public VariableVectorCondition(int capacity) : base(capacity) { }
    47     public VariableVectorCondition(IDictionary<StringValue, IVariable> dictionary) : base(dictionary) { }
    48     public override IDeepCloneable Clone(Cloner cloner) {
    49       return new VariableVectorCondition(this, cloner);
    50     }
     50    public VariableVectorCondition(IDictionary<string, IVariable> dictionary) : base(dictionary) { }
    5151
    5252    public bool Match(IInput target) {
    5353      var targetCast = target as VariableVectorInput;
    5454      if (targetCast == null) { return false; }
    55       if (this.Order.SequenceEqual(targetCast.Order)) { return false; }
    56       foreach (var keyValuePair in targetCast) {
    57         if (!this[keyValuePair.Key].MatchInput(keyValuePair.Value.Value)) {
     55      if (!this.Keys.All(x => targetCast.Keys.Contains(x))) { return false; }
     56      foreach (var key in this.Keys) {
     57        if (!this[key].MatchInput(targetCast[key])) {
    5858          return false;
    5959        }
     
    6464    public void Add(IEnumerable<IVariable> condition) {
    6565      foreach (var variable in condition) {
    66         this.Add(new StringValue(variable.VariableName), variable);
     66        this.Add(variable.VariableName, variable);
    6767      }
    6868    }
     
    7272      bool first = true;
    7373      foreach (var variable in this.Values) {
    74         if (!first) {
     74        if (first) {
    7575          first = false;
    7676        } else {
     
    9393
    9494    public bool Identical(VariableVectorCondition target) {
    95       if (this.Order.SequenceEqual(target.Order)) { return false; }
     95      if (!this.Order.SequenceEqual(target.Order)) { return false; }
    9696      foreach (var keyValuePair in target) {
    9797        if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {
     
    101101      return true;
    102102    }
     103
     104    public virtual string ItemName {
     105      get { return ItemAttribute.GetName(this.GetType()); }
     106    }
     107    public virtual string ItemDescription {
     108      get { return ItemAttribute.GetDescription(this.GetType()); }
     109    }
     110    public Version ItemVersion {
     111      get { return ItemAttribute.GetVersion(this.GetType()); }
     112    }
     113    public static Image StaticItemImage {
     114      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
     115    }
     116    public virtual Image ItemImage {
     117      get { return ItemAttribute.GetImage(this.GetType()); }
     118    }
     119
     120    public virtual IDeepCloneable Clone(Cloner cloner) {
     121      return new VariableVectorCondition(this, cloner);
     122    }
     123
     124    public object Clone() {
     125      return Clone(new Cloner());
     126    }
     127
     128    public event EventHandler ItemImageChanged;
     129    protected virtual void OnItemImageChanged() {
     130      EventHandler handler = ItemImageChanged;
     131      if (handler != null) handler(this, EventArgs.Empty);
     132    }
     133    public event EventHandler ToStringChanged;
     134    protected virtual void OnToStringChanged() {
     135      EventHandler handler = ToStringChanged;
     136      if (handler != null) handler(this, EventArgs.Empty);
     137    }
    103138  }
    104139}
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs

    r9204 r9226  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
     24using System.Drawing;
    2325using System.Linq;
     26using System.Text;
    2427using HeuristicLab.Common;
    2528using HeuristicLab.Core;
    26 using HeuristicLab.Data;
    2729using HeuristicLab.Encodings.ConditionActionEncoding;
    2830using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     
    3133  [StorableClass]
    3234  [Item("VariableVectorInput", "")]
    33   public class VariableVectorInput : ItemDictionary<StringValue, StringValue>, IInput {
     35  public class VariableVectorInput : Dictionary<string, string>, IInput {
    3436
    35     public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
     37    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
    3638
    3739    [StorableConstructor]
    38     protected VariableVectorInput(bool deserializing) : base(deserializing) { }
    39     protected VariableVectorInput(VariableVectorInput original, Cloner cloner)
    40       : base(original, cloner) {
     40    protected VariableVectorInput(bool deserializing) { }
     41    protected VariableVectorInput(VariableVectorInput original, Cloner cloner) {
     42      foreach (var item in original) {
     43        Add((string)item.Key.Clone(), (string)item.Value.Clone());
     44      }
    4145    }
    4246    public VariableVectorInput() : base() { }
    4347    public VariableVectorInput(int capacity) : base(capacity) { }
    44     public VariableVectorInput(IDictionary<StringValue, StringValue> dictionary) : base(dictionary) { }
    45     public override IDeepCloneable Clone(Cloner cloner) {
     48    public VariableVectorInput(IDictionary<string, string> dictionary) : base(dictionary) { }
     49
     50    public override string ToString() {
     51      StringBuilder sb = new StringBuilder();
     52      bool first = true;
     53      foreach (var item in this) {
     54        if (first) {
     55          first = false;
     56        } else {
     57          sb.Append("; ");
     58        }
     59        sb.Append(String.Format("{0}: {1}", item.Key, item.Value));
     60      }
     61      return sb.ToString();
     62    }
     63
     64    public virtual string ItemName {
     65      get { return ItemAttribute.GetName(this.GetType()); }
     66    }
     67    public virtual string ItemDescription {
     68      get { return ItemAttribute.GetDescription(this.GetType()); }
     69    }
     70    public Version ItemVersion {
     71      get { return ItemAttribute.GetVersion(this.GetType()); }
     72    }
     73    public static Image StaticItemImage {
     74      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
     75    }
     76    public virtual Image ItemImage {
     77      get { return ItemAttribute.GetImage(this.GetType()); }
     78    }
     79
     80    public virtual IDeepCloneable Clone(Cloner cloner) {
    4681      return new VariableVectorInput(this, cloner);
     82    }
     83
     84    public object Clone() {
     85      return Clone(new Cloner());
     86    }
     87
     88    public event EventHandler ItemImageChanged;
     89    protected virtual void OnItemImageChanged() {
     90      EventHandler handler = ItemImageChanged;
     91      if (handler != null) handler(this, EventArgs.Empty);
     92    }
     93    public event EventHandler ToStringChanged;
     94    protected virtual void OnToStringChanged() {
     95      EventHandler handler = ToStringChanged;
     96      if (handler != null) handler(this, EventArgs.Empty);
    4797    }
    4898  }
  • branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj

    r9194 r9226  
    7171      <Private>False</Private>
    7272    </Reference>
    73     <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
     73    <Reference Include="HeuristicLab.Problems.Instances-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    7474      <Private>False</Private>
    7575    </Reference>
    76     <Reference Include="HeuristicLab.Problems.Instances-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
    7776    <Reference Include="System" />
    7877    <Reference Include="System.Core" />
     
    8584  </ItemGroup>
    8685  <ItemGroup>
    87     <Compile Include="Implementation\ConditionActionClassificationProblem.cs" />
    88     <Compile Include="Implementation\ConditionActionClassificationProblemData.cs" />
     86    <Compile Include="ConditionActionClassificationProblem.cs" />
     87    <Compile Include="ConditionActionClassificationProblemData.cs" />
    8988    <Compile Include="Plugin.cs" />
    9089    <None Include="HeuristicLab.snk" />
     
    9998      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
    10099      <Name>HeuristicLab.Core-3.3</Name>
     100      <Private>False</Private>
    101101    </ProjectReference>
    102102    <ProjectReference Include="..\..\HeuristicLab.Encodings.CombinedIntegerVectorEncoding\3.3\HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj">
     
    109109      <Name>HeuristicLab.Encodings.ConditionActionEncoding-3.3</Name>
    110110      <Private>False</Private>
     111    </ProjectReference>
     112    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj">
     113      <Project>{DF87C13E-A889-46FF-8153-66DCAA8C5674}</Project>
     114      <Name>HeuristicLab.Problems.DataAnalysis-3.4</Name>
    111115    </ProjectReference>
    112116  </ItemGroup>
  • branches/LearningClassifierSystems/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs

    r8798 r9226  
    159159    }
    160160
     161    public IList GetValues(string variableName) {
     162      IList list;
     163      if (!variableValues.TryGetValue(variableName, out list))
     164        throw new ArgumentException("The variable " + variableName + " does not exist in the dataset.");
     165      return list;
     166    }
     167
    161168    public IEnumerable<double> GetDoubleValues(string variableName) {
    162169      IList list;
     
    227234    public string GetValue(int rowIndex, int columnIndex) {
    228235      return variableValues[variableNames[columnIndex]][rowIndex].ToString();
     236    }
     237    public string GetValue(int rowIndex, string variableName) {
     238      if (!variableValues.Keys.Contains(variableName)) {
     239        throw new ArgumentException("The variable " + variableName + " does not exist in the dataset.");
     240      }
     241      return variableValues[variableName][rowIndex].ToString();
    229242    }
    230243    public bool SetValue(string value, int rowIndex, int columnIndex) {
  • branches/LearningClassifierSystems/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj

    r8861 r9226  
    4141    <DebugType>full</DebugType>
    4242    <Optimize>false</Optimize>
    43     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     43    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    4444    <DefineConstants>DEBUG;TRACE</DefineConstants>
    4545    <ErrorReport>prompt</ErrorReport>
     
    5050    <DebugType>pdbonly</DebugType>
    5151    <Optimize>true</Optimize>
    52     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     52    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    5353    <DefineConstants>TRACE</DefineConstants>
    5454    <ErrorReport>prompt</ErrorReport>
     
    5858  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
    5959    <DebugSymbols>true</DebugSymbols>
    60     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     60    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    6161    <DefineConstants>DEBUG;TRACE</DefineConstants>
    6262    <DebugType>full</DebugType>
     
    6666  </PropertyGroup>
    6767  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
    68     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     68    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    6969    <DefineConstants>TRACE</DefineConstants>
    7070    <Optimize>true</Optimize>
     
    7676  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    7777    <DebugSymbols>true</DebugSymbols>
    78     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     78    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    7979    <DefineConstants>DEBUG;TRACE</DefineConstants>
    8080    <DebugType>full</DebugType>
     
    8484  </PropertyGroup>
    8585  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    86     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     86    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    8787    <DefineConstants>TRACE</DefineConstants>
    8888    <Optimize>true</Optimize>
     
    9393  </PropertyGroup>
    9494  <ItemGroup>
    95     <Reference Include="ALGLIB-3.6.0, Version=3.6.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    96       <HintPath>..\..\bin\ALGLIB-3.6.0.dll</HintPath>
    97       <Private>False</Private>
    98     </Reference>
    99     <Reference Include="HeuristicLab.ALGLIB-3.6.0, Version=3.6.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    100       <HintPath>..\..\bin\HeuristicLab.ALGLIB-3.6.0.dll</HintPath>
    101       <Private>False</Private>
     95    <Reference Include="ALGLIB-3.6.0">
     96      <HintPath>..\..\..\..\trunk\sources\bin\ALGLIB-3.6.0.dll</HintPath>
     97    </Reference>
     98    <Reference Include="HeuristicLab.ALGLIB-3.6.0">
     99      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.ALGLIB-3.6.0.dll</HintPath>
     100    </Reference>
     101    <Reference Include="HeuristicLab.Collections-3.3">
     102      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
     103    </Reference>
     104    <Reference Include="HeuristicLab.Common-3.3">
     105      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
     106    </Reference>
     107    <Reference Include="HeuristicLab.Common.Resources-3.3">
     108      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
     109    </Reference>
     110    <Reference Include="HeuristicLab.Data-3.3">
     111      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
     112    </Reference>
     113    <Reference Include="HeuristicLab.Optimization-3.3">
     114      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
     115    </Reference>
     116    <Reference Include="HeuristicLab.Parameters-3.3">
     117      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
     118    </Reference>
     119    <Reference Include="HeuristicLab.Persistence-3.3">
     120      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
     121    </Reference>
     122    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
     123      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
     124    </Reference>
     125    <Reference Include="HeuristicLab.Problems.Instances-3.3">
     126      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
    102127    </Reference>
    103128    <Reference Include="System" />
     
    239264  </ItemGroup>
    240265  <ItemGroup>
    241     <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
    242       <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
    243       <Name>HeuristicLab.Collections-3.3</Name>
    244       <Private>False</Private>
    245     </ProjectReference>
    246     <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
    247       <Project>{0E27A536-1C4A-4624-A65E-DC4F4F23E3E1}</Project>
    248       <Name>HeuristicLab.Common.Resources-3.3</Name>
    249       <Private>False</Private>
    250     </ProjectReference>
    251     <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
    252       <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
    253       <Name>HeuristicLab.Common-3.3</Name>
    254       <Private>False</Private>
    255     </ProjectReference>
    256266    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
    257267      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
    258268      <Name>HeuristicLab.Core-3.3</Name>
    259       <Private>False</Private>
    260     </ProjectReference>
    261     <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
    262       <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
    263       <Name>HeuristicLab.Data-3.3</Name>
    264       <Private>False</Private>
    265     </ProjectReference>
    266     <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
    267       <Project>{14AB8D24-25BC-400C-A846-4627AA945192}</Project>
    268       <Name>HeuristicLab.Optimization-3.3</Name>
    269       <Private>False</Private>
    270     </ProjectReference>
    271     <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
    272       <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
    273       <Name>HeuristicLab.Parameters-3.3</Name>
    274       <Private>False</Private>
    275     </ProjectReference>
    276     <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
    277       <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
    278       <Name>HeuristicLab.Persistence-3.3</Name>
    279       <Private>False</Private>
    280     </ProjectReference>
    281     <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
    282       <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
    283       <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
    284       <Private>False</Private>
    285     </ProjectReference>
    286     <ProjectReference Include="..\..\HeuristicLab.Problems.Instances\3.3\HeuristicLab.Problems.Instances-3.3.csproj">
    287       <Project>{3540E29E-4793-49E7-8EE2-FEA7F61C3994}</Project>
    288       <Name>HeuristicLab.Problems.Instances-3.3</Name>
    289269      <Private>False</Private>
    290270    </ProjectReference>
  • branches/LearningClassifierSystems/LearningClassifierSystem.sln

    r9194 r9226  
    1818Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.XCS.Views-3.3", "HeuristicLab.Problems.XCS.Views\3.3\HeuristicLab.Problems.XCS.Views-3.3.csproj", "{8FFB8E0F-BC17-4D72-AF0F-E67A22F8EDE5}"
    1919EndProject
    20 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Instances.ConditionActionClassification", "HeuristicLab.Problems.Instances.ConditionActionClassification\3.3\HeuristicLab.Problems.Instances.ConditionActionClassification.csproj", "{1CC7585E-DD22-41FA-869B-93DE41EA8936}"
     20Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Instances.ConditionActionClassification-3.3", "HeuristicLab.Problems.Instances.ConditionActionClassification\3.3\HeuristicLab.Problems.Instances.ConditionActionClassification-3.3.csproj", "{1CC7585E-DD22-41FA-869B-93DE41EA8936}"
    2121EndProject
    2222Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Core-3.3", "HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj", "{C36BD924-A541-4A00-AFA8-41701378DDC5}"
    2323EndProject
    2424Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Encodings.VariableVector-3.3", "HeuristicLab.Encodings.VariableVector\3.3\HeuristicLab.Encodings.VariableVector-3.3.csproj", "{7C116F48-7218-4105-BD6E-EE868E2D4823}"
     25EndProject
     26Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.CombinedIntegerVectorClassification-3.3", "HeuristicLab.Problems.CombinedIntegerVectorClassification\3.3\HeuristicLab.Problems.CombinedIntegerVectorClassification-3.3.csproj", "{E8D42226-3FAF-49AD-91E9-D48A422A1BD0}"
     27EndProject
     28Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.VariableVectorClassification-3.3", "HeuristicLab.Problems.VariableVectorClassification\3.3\HeuristicLab.Problems.VariableVectorClassification-3.3.csproj", "{4833BCCD-C7FB-40AB-ABE6-31A8A1FAA3CC}"
     29EndProject
     30Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.DataAnalysis-3.4", "HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj", "{DF87C13E-A889-46FF-8153-66DCAA8C5674}"
    2531EndProject
    2632Global
     
    106112    {7C116F48-7218-4105-BD6E-EE868E2D4823}.Release|x64.ActiveCfg = Release|Any CPU
    107113    {7C116F48-7218-4105-BD6E-EE868E2D4823}.Release|x86.ActiveCfg = Release|Any CPU
     114    {E8D42226-3FAF-49AD-91E9-D48A422A1BD0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     115    {E8D42226-3FAF-49AD-91E9-D48A422A1BD0}.Debug|Any CPU.Build.0 = Debug|Any CPU
     116    {E8D42226-3FAF-49AD-91E9-D48A422A1BD0}.Debug|x64.ActiveCfg = Debug|Any CPU
     117    {E8D42226-3FAF-49AD-91E9-D48A422A1BD0}.Debug|x86.ActiveCfg = Debug|Any CPU
     118    {E8D42226-3FAF-49AD-91E9-D48A422A1BD0}.Release|Any CPU.ActiveCfg = Release|Any CPU
     119    {E8D42226-3FAF-49AD-91E9-D48A422A1BD0}.Release|Any CPU.Build.0 = Release|Any CPU
     120    {E8D42226-3FAF-49AD-91E9-D48A422A1BD0}.Release|x64.ActiveCfg = Release|Any CPU
     121    {E8D42226-3FAF-49AD-91E9-D48A422A1BD0}.Release|x86.ActiveCfg = Release|Any CPU
     122    {4833BCCD-C7FB-40AB-ABE6-31A8A1FAA3CC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     123    {4833BCCD-C7FB-40AB-ABE6-31A8A1FAA3CC}.Debug|Any CPU.Build.0 = Debug|Any CPU
     124    {4833BCCD-C7FB-40AB-ABE6-31A8A1FAA3CC}.Debug|x64.ActiveCfg = Debug|Any CPU
     125    {4833BCCD-C7FB-40AB-ABE6-31A8A1FAA3CC}.Debug|x86.ActiveCfg = Debug|Any CPU
     126    {4833BCCD-C7FB-40AB-ABE6-31A8A1FAA3CC}.Release|Any CPU.ActiveCfg = Release|Any CPU
     127    {4833BCCD-C7FB-40AB-ABE6-31A8A1FAA3CC}.Release|Any CPU.Build.0 = Release|Any CPU
     128    {4833BCCD-C7FB-40AB-ABE6-31A8A1FAA3CC}.Release|x64.ActiveCfg = Release|Any CPU
     129    {4833BCCD-C7FB-40AB-ABE6-31A8A1FAA3CC}.Release|x86.ActiveCfg = Release|Any CPU
     130    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     131    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Debug|Any CPU.Build.0 = Debug|Any CPU
     132    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Debug|x64.ActiveCfg = Debug|x64
     133    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Debug|x64.Build.0 = Debug|x64
     134    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Debug|x86.ActiveCfg = Debug|x86
     135    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Debug|x86.Build.0 = Debug|x86
     136    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Release|Any CPU.ActiveCfg = Release|Any CPU
     137    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Release|Any CPU.Build.0 = Release|Any CPU
     138    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Release|x64.ActiveCfg = Release|x64
     139    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Release|x64.Build.0 = Release|x64
     140    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Release|x86.ActiveCfg = Release|x86
     141    {DF87C13E-A889-46FF-8153-66DCAA8C5674}.Release|x86.Build.0 = Release|x86
    108142  EndGlobalSection
    109143  GlobalSection(SolutionProperties) = preSolution
Note: See TracChangeset for help on using the changeset viewer.