Changeset 9194


Ignore:
Timestamp:
01/28/13 17:54:46 (5 years ago)
Author:
sforsten
Message:

#1980:

  • added necessary interface ICondition, IAction, IInput
  • removed not used class MatchSelector and interface IMatchSelector
  • added constructors to ItemDictionary
  • added new encoding
Location:
branches/LearningClassifierSystems
Files:
28 added
2 deleted
41 edited

Legend:

Unmodified
Added
Removed
  • branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj

    r9160 r9194  
    5050    <Reference Include="HeuristicLab.Common-3.3">
    5151      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
    52       <Private>False</Private>
    53     </Reference>
    54     <Reference Include="HeuristicLab.Core-3.3">
    55       <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
    5652      <Private>False</Private>
    5753    </Reference>
     
    116112  </ItemGroup>
    117113  <ItemGroup>
     114    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
     115      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
     116      <Name>HeuristicLab.Core-3.3</Name>
     117    </ProjectReference>
    118118    <ProjectReference Include="..\..\HeuristicLab.Encodings.CombinedIntegerVectorEncoding\3.3\HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj">
    119119      <Project>{CE7163C5-BFFE-45F0-9BD0-E10EF24E8BD2}</Project>
  • branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs

    r9175 r9194  
    7676    private DoDeletionBeforeCoveringOperator doDeletionBeforeCovering;
    7777    private CoveringOperator covering;
     78    private CountNumberOfUniqueActions countNumberOfUniqueActions;
    7879
    7980    private UniformSomePositionManipulator test;
     
    136137      ConditionalSelector actionMatchSelector = new ConditionalSelector();
    137138      SubScopesProcessor matchSetSubScopesProcessor = new SubScopesProcessor();
    138       CountNumberOfUniqueActions countNumberOfUniqueActions = new CountNumberOfUniqueActions();
     139      countNumberOfUniqueActions = new CountNumberOfUniqueActions();
    139140      doDeletionBeforeCovering = new DoDeletionBeforeCoveringOperator();
    140141      ConditionalBranch doDeletionBeforeCoveringConditionalBranch = new ConditionalBranch();
     
    439440      classifierFetcher.OperatorParameter.ActualName = problem.ClassifierFetcherParameter.Name;
    440441
    441       test.FetchedClassifierParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
     442      test.FetchedConditionParameter.ActualName = problem.ClassifierFetcher.CurrentInputToMatchParameter.ActualName;
    442443      test.PossibleActionsParameter.ActualName = problem.PossibleActionsConcreteClassParameter.Name;
    443444
     
    454455      actionSetSubsumption.OperatorParameter.ActualName = problem.ActionSetSubsumptionOperatorParameter.Name;
    455456
    456       matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
     457      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentInputToMatchParameter.ActualName;
    457458
    458459      doDeletionBeforeCovering.MinimalNumberOfUniqueActionsParameter.ActualName = problem.ThetaMinimalNumberOfActionsParameter.Name;
     460      doDeletionBeforeCovering.ClassifierComparerParameter.ActualName = problem.ClassifierComparerParameter.Name;
    459461
    460462      covering.SolutionCreatorParameter.ActualName = problem.CoveringSolutionCreatorParameter.Name;
     
    465467      predictionArrayCalculator.PredictionParameter.ActualName = problem.Evaluator.PredictionParameter.ActualName;
    466468      predictionArrayCalculator.FitnessParameter.ActualName = problem.Evaluator.FitnessParameter.ActualName;
     469      predictionArrayCalculator.ClassifierComparerParameter.ActualName = problem.ClassifierComparerParameter.Name;
     470
     471      countNumberOfUniqueActions.ClassifierComparerParameter.ActualName = problem.ClassifierComparerParameter.Name;
    467472    }
    468473    //private void ParameterizeSelectors() {
  • branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemDictionary.cs

    r7725 r9194  
    5959    public ItemDictionary() : base() { }
    6060    public ItemDictionary(int capacity) : base(capacity) { }
     61    public ItemDictionary(IEqualityComparer<TKey> comparer) : base(comparer) { }
    6162    public ItemDictionary(IDictionary<TKey, TValue> dictionary) : base(dictionary) { }
     63    public ItemDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) : base(dictionary, comparer) { }
    6264
    6365    public object Clone() {
  • branches/LearningClassifierSystems/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj

    r9178 r9194  
    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>
     
    5252    <DebugType>pdbonly</DebugType>
    5353    <Optimize>true</Optimize>
    54     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     54    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    5555    <DefineConstants>TRACE</DefineConstants>
    5656    <ErrorReport>prompt</ErrorReport>
     
    6363  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    6464    <DebugSymbols>true</DebugSymbols>
    65     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     65    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    6666    <DefineConstants>DEBUG;TRACE</DefineConstants>
    6767    <DebugType>full</DebugType>
     
    7171  </PropertyGroup>
    7272  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    73     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     73    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    7474    <DefineConstants>TRACE</DefineConstants>
    7575    <DocumentationFile>
     
    8383  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
    8484    <DebugSymbols>true</DebugSymbols>
    85     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     85    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    8686    <DefineConstants>DEBUG;TRACE</DefineConstants>
    8787    <DebugType>full</DebugType>
     
    9191  </PropertyGroup>
    9292  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
    93     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     93    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    9494    <DefineConstants>TRACE</DefineConstants>
    9595    <DocumentationFile>
     
    102102  </PropertyGroup>
    103103  <ItemGroup>
     104    <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
     105      <Private>False</Private>
     106    </Reference>
     107    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
     108      <Private>False</Private>
     109    </Reference>
     110    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
     111      <Private>False</Private>
     112    </Reference>
     113    <Reference Include="HeuristicLab.Persistence-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
     114      <Private>False</Private>
     115    </Reference>
     116    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
     117      <Private>False</Private>
     118    </Reference>
    104119    <Reference Include="System" />
    105120    <Reference Include="System.Core">
     
    205220  </ItemGroup>
    206221  <ItemGroup>
    207     <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
    208       <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
    209       <Name>HeuristicLab.Collections-3.3</Name>
    210       <Private>False</Private>
    211     </ProjectReference>
    212     <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
    213       <Project>{0E27A536-1C4A-4624-A65E-DC4F4F23E3E1}</Project>
    214       <Name>HeuristicLab.Common.Resources-3.3</Name>
    215       <Private>False</Private>
    216     </ProjectReference>
    217     <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
    218       <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
    219       <Name>HeuristicLab.Common-3.3</Name>
    220       <Private>False</Private>
    221     </ProjectReference>
    222     <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
    223       <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
    224       <Name>HeuristicLab.Persistence-3.3</Name>
    225       <Private>False</Private>
    226     </ProjectReference>
    227     <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
    228       <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
    229       <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
    230       <Private>False</Private>
    231     </ProjectReference>
    232   </ItemGroup>
    233   <ItemGroup>
    234222    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
    235223      <Visible>False</Visible>
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs

    r9175 r9194  
    2121
    2222using System;
     23using System.Collections.Generic;
    2324using System.Linq;
    2425using System.Text;
     
    3334  [StorableClass]
    3435  [Item("CombinedIntegerVector", "Represents a combined vector of integer values.")]
    35   public class CombinedIntegerVector : IntegerVector, IClassifier {
     36  public class CombinedIntegerVector : IntegerVector, IClassifier, ICondition, IAction, IInput {
    3637
    3738    [Storable]
     
    121122    }
    122123
    123     public IClassifier Condition {
     124    public ICondition Condition {
    124125      get {
    125126        int[] condition = new int[Length - actionLength];
     
    129130    }
    130131
    131     public IClassifier Action {
     132    public IAction Action {
    132133      get {
    133134        int[] action = new int[actionLength];
     
    152153    }
    153154
    154     public bool MatchCondition(IClassifier target) {
     155    public bool MatchInput(IInput target) {
    155156      var targetVector = target as CombinedIntegerVector;
    156157      if (targetVector == null) return false;
    157       if (targetVector.Length != this.Length) return false;
     158      if (targetVector.Length - targetVector.actionLength != this.Length - this.actionLength) return false;
    158159
    159160      int curbounds;
     
    171172    }
    172173
     174    public bool MatchAction(IClassifier target) {
     175      return MatchAction(target.Action);
     176    }
     177
    173178    // no "don't care" symbols have to be considered
    174     public bool MatchAction(IClassifier target) {
     179    public bool MatchAction(IAction target) {
    175180      var targetVector = target as CombinedIntegerVector;
    176181      if (targetVector == null) return false;
     
    188193
    189194    public bool IsMoreGeneral(IClassifier target) {
     195      return IsMoreGeneral(target as ICondition);
     196    }
     197
     198    public bool IsMoreGeneral(ICondition target) {
    190199      var targetVector = target as CombinedIntegerVector;
    191200      int curbounds;
     
    201210      return true;
    202211    }
     212
     213    #region ICondition Members
     214    public bool Match(IInput target) {
     215      return MatchInput(target);
     216    }
     217    #endregion
     218
     219    #region IAction Members
     220    public bool Match(IAction target) {
     221      return MatchAction(target);
     222    }
     223    #endregion
    203224
    204225    private int NumberOfGeneralSymbols() {
     
    233254    }
    234255
    235     public override bool Equals(object obj) {
    236       var cast = obj as CombinedIntegerVector;
    237       if (cast != null) {
    238         return this.Equals(cast);
    239       }
    240       return false;
    241     }
    242 
    243     public bool Equals(IClassifier other) {
    244       var cast = other as CombinedIntegerVector;
     256    public bool Identical(IClassifier target) {
     257      var cast = target as CombinedIntegerVector;
    245258      if (cast == null) { return false; }
    246259      for (int i = 0; i < array.Length; i++) {
     
    252265    }
    253266
     267    public override bool Equals(object obj) {
     268      return base.Equals(obj);
     269    }
     270
    254271    public override int GetHashCode() {
    255       int result = actionLength;
    256       for (int i = 0; i < array.Length; i++) {
    257         result ^= array[i];
    258       }
    259       return result.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      }
    260316    }
    261317  }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs

    r9110 r9194  
    3939      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Child"]; }
    4040    }
    41     public ILookupParameter<CombinedIntegerVector> FetchedClassifierParameter {
     41    public ILookupParameter<CombinedIntegerVector> FetchedConditionParameter {
    4242      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Parent"]; }
    4343    }
     
    5757
    5858    public sealed override IOperation Apply() {
    59       ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedClassifierParameter.ActualValue, ChildParameter.ActualValue);
     59      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedConditionParameter.ActualValue, ChildParameter.ActualValue);
    6060      return base.Apply();
    6161    }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs

    r9110 r9194  
    3434
    3535    #region Parameter Properties
    36     public ILookupParameter<IClassifier> CoverClassifierParameter {
    37       get { return (ILookupParameter<IClassifier>)Parameters["CoverClassifier"]; }
     36    public ILookupParameter<IInput> CoverInputParameter {
     37      get { return (ILookupParameter<IInput>)Parameters["CoverInput"]; }
    3838    }
    39     public ILookupParameter<IClassifier> ActionParameter {
    40       get { return (ILookupParameter<IClassifier>)Parameters["Action"]; }
     39    public ILookupParameter<IAction> ActionParameter {
     40      get { return (ILookupParameter<IAction>)Parameters["Action"]; }
    4141    }
    4242    public IValueLookupParameter<IClassifier> CreatedClassifierParameter {
     
    6262    public CombinedIntegerVectorCoveringCreator()
    6363      : base() {
    64       Parameters.Add(new LookupParameter<IClassifier>("CoverClassifier"));
    65       Parameters.Add(new LookupParameter<IClassifier>("Action"));
     64      Parameters.Add(new LookupParameter<IInput>("CoverInput"));
     65      Parameters.Add(new LookupParameter<IAction>("Action"));
    6666      Parameters.Add(new ValueLookupParameter<IClassifier>("CreatedClassifier"));
    6767      Parameters.Add(new LookupParameter<PercentValue>("ChangeSymbolProbability"));
     
    7070
    7171    public override IOperation Apply() {
    72       CombinedIntegerVector newCondition = (CombinedIntegerVector)CoverClassifierParameter.ActualValue.Condition.Clone();
     72      CombinedIntegerVector newCondition = (CombinedIntegerVector)CoverInputParameter.ActualValue.Clone();
    7373
    74       CombinedIntegerVector condition = (CombinedIntegerVector)CoverClassifierParameter.ActualValue.Condition;
    75       CombinedIntegerVector action = (CombinedIntegerVector)ActionParameter.ActualValue.Action;
     74      CombinedIntegerVector condition = (CombinedIntegerVector)CoverInputParameter.ActualValue;
     75      CombinedIntegerVector action = (CombinedIntegerVector)ActionParameter.ActualValue;
    7676
    7777      newCondition = UniformSomePositionManipulator.ManipulateCondition(RandomParameter.ActualValue, condition, newCondition, ChangeSymbolProbabilityParameter.ActualValue.Value);
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj

    r9154 r9194  
    8989      <Private>False</Private>
    9090    </Reference>
    91     <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    92       <Private>False</Private>
    93     </Reference>
    9491    <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    9592      <Private>False</Private>
     
    149146  </ItemGroup>
    150147  <ItemGroup>
     148    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
     149      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
     150      <Name>HeuristicLab.Core-3.3</Name>
     151    </ProjectReference>
    151152    <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
    152153      <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs

    r9110 r9194  
    2929  public interface ICombinedIntegerVectorManipulator : IManipulator, ICombinedIntegerVectorOperator {
    3030    ILookupParameter<CombinedIntegerVector> ChildParameter { get; }
    31     ILookupParameter<CombinedIntegerVector> FetchedClassifierParameter { get; }
     31    ILookupParameter<CombinedIntegerVector> FetchedConditionParameter { get; }
    3232  }
    3333}
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/ActionSelector.cs

    r9089 r9194  
    3737      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
    3838    }
    39     public IValueLookupParameter<IClassifier> SelectedActionParameter {
    40       get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
     39    public IValueLookupParameter<IAction> SelectedActionParameter {
     40      get { return (IValueLookupParameter<IAction>)Parameters["SelectedAction"]; }
    4141    }
    42     public ILookupParameter<IItemDictionary<IClassifier, DoubleValue>> PredictionArrayParameter {
    43       get { return (ILookupParameter<IItemDictionary<IClassifier, DoubleValue>>)Parameters["PredictionArray"]; }
     42    public ILookupParameter<IItemDictionary<IAction, DoubleValue>> PredictionArrayParameter {
     43      get { return (ILookupParameter<IItemDictionary<IAction, DoubleValue>>)Parameters["PredictionArray"]; }
    4444    }
    4545    public ILookupParameter<PercentValue> ExplorationProbabilityParameter {
     
    5555      : base() {
    5656      Parameters.Add(new LookupParameter<IRandom>("Random"));
    57       Parameters.Add(new ValueLookupParameter<IClassifier>("SelectedAction", "Action, which has been selected."));
    58       Parameters.Add(new LookupParameter<IItemDictionary<IClassifier, DoubleValue>>("PredictionArray"));
     57      Parameters.Add(new ValueLookupParameter<IAction>("SelectedAction", "Action, which has been selected."));
     58      Parameters.Add(new LookupParameter<IItemDictionary<IAction, DoubleValue>>("PredictionArray"));
    5959      Parameters.Add(new LookupParameter<PercentValue>("ExplorationProbability"));
    6060    }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/MaxValueActionSelector.cs

    r9089 r9194  
    3636      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["ValueParameter"]; }
    3737    }
     38    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
     39      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
     40    }
    3841
    3942    [StorableConstructor]
     
    4346      : base() {
    4447      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ValueParameter", "DoubleValue which will be summed up."));
     48      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
    4549    }
    4650    public override IDeepCloneable Clone(Cloner cloner) {
     
    4852    }
    4953
    50     protected override IClassifier SelectAction(List<IScope> scopes) {
    51       Dictionary<IClassifier, double> actionSet = new Dictionary<IClassifier, double>();
     54    protected override IAction SelectAction(List<IScope> scopes) {
     55      Dictionary<IAction, double> actionSet = new Dictionary<IAction, double>(ClassifierComparerParameter.ActualValue);
    5256      for (int i = 0; i < MatchParameter.ActualValue.Length; i++) {
    5357        var action = MatchParameter.ActualValue[i].Action;
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/OldActionSelector.cs

    r9089 r9194  
    3838      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["MatchParameter"]; }
    3939    }
    40     public IValueLookupParameter<IClassifier> SelectedActionParameter {
    41       get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
     40    public IValueLookupParameter<IAction> SelectedActionParameter {
     41      get { return (IValueLookupParameter<IAction>)Parameters["SelectedAction"]; }
    4242    }
    4343
     
    5454      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which sub-scopes should be selected."));
    5555      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
    56       Parameters.Add(new ValueLookupParameter<IClassifier>("SelectedAction", "Action, which has been selected."));
     56      Parameters.Add(new ValueLookupParameter<IAction>("SelectedAction", "Action, which has been selected."));
    5757    }
    5858
     
    6363    }
    6464
    65     protected abstract IClassifier SelectAction(List<IScope> scopes);
     65    protected abstract IAction SelectAction(List<IScope> scopes);
    6666  }
    6767}
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/RandomActionSelector.cs

    r9089 r9194  
    4545    }
    4646
    47     protected override IClassifier SelectAction(List<IScope> scopes) {
     47    protected override IAction SelectAction(List<IScope> scopes) {
    4848      IRandom random = RandomParameter.ActualValue;
    4949      int index = random.Next(MatchParameter.ActualValue.Length);
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Analyzer/XCSSolutionAnalyzer.cs

    r9175 r9194  
    6666      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
    6767    }
     68    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
     69      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
     70    }
    6871
    6972    public ResultCollection Results { get { return ResultsParameter.ActualValue; } }
     
    8487      Parameters.Add(new LookupParameter<IConditionActionProblemData>("ProblemData", ""));
    8588      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the solution should be stored."));
     89      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
    8690    }
    8791
     
    105109
    106110      XCSModel xcsModel = new XCSModel(xcsClassifiers);
    107 
     111      xcsModel.ClassifierComparer = ClassifierComparerParameter.ActualValue;
    108112      UseCurrentXCSSolution(xcsModel.CreateConditionActionSolution(problemData));
    109113      return base.Apply();
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs

    r9110 r9194  
    3535
    3636    #region Parameter Properties
    37     public ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter {
    38       get { return (ILookupParameter<IItemSet<IClassifier>>)Parameters["ActionsInMatchSet"]; }
     37    public ILookupParameter<IItemSet<IAction>> ActionsInMatchSetParameter {
     38      get { return (ILookupParameter<IItemSet<IAction>>)Parameters["ActionsInMatchSet"]; }
    3939    }
    40     public ILookupParameter<IItemSet<IClassifier>> PossibleActionsParameter {
    41       get { return (ILookupParameter<IItemSet<IClassifier>>)Parameters["PossibleActions"]; }
     40    public ILookupParameter<IItemSet<IAction>> PossibleActionsParameter {
     41      get { return (ILookupParameter<IItemSet<IAction>>)Parameters["PossibleActions"]; }
    4242    }
    4343    public ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter {
     
    7777    public CoveringOperator()
    7878      : base() {
    79       Parameters.Add(new LookupParameter<IClassifier>("CoverClassifier"));
    80       Parameters.Add(new LookupParameter<IItemSet<IClassifier>>("ActionsInMatchSet"));
    81       Parameters.Add(new LookupParameter<IItemSet<IClassifier>>("PossibleActions"));
     79      Parameters.Add(new LookupParameter<IItemSet<IAction>>("ActionsInMatchSet"));
     80      Parameters.Add(new LookupParameter<IItemSet<IAction>>("PossibleActions"));
    8281      Parameters.Add(new LookupParameter<IntValue>("MinimalNumberOfUniqueActions"));
    8382      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator"));
     
    9594      bool parallel = ParallelParameter.ActualValue.Value;
    9695
    97       IItemSet<IClassifier> clone = (IItemSet<IClassifier>)PossibleActionsParameter.ActualValue.Clone();
     96      IItemSet<IAction> clone = (IItemSet<IAction>)PossibleActionsParameter.ActualValue.Clone();
    9897      clone.ExceptWith(ActionsInMatchSetParameter.ActualValue);
    9998
     
    116115          VariableCreator variableCreator = new VariableCreator();
    117116          int pos = RandomParameter.ActualValue.Next(clone.Count);
    118           IClassifier action = clone.ElementAt(pos);
     117          IAction action = clone.ElementAt(pos);
    119118          clone.Remove(action);
    120           variableCreator.CollectedValues.Add(new ValueParameter<IClassifier>("Action", action));
     119          variableCreator.CollectedValues.Add(new ValueParameter<IAction>("Action", action));
    121120          variableCreation.Add(ExecutionContext.CreateOperation(variableCreator, CurrentScope.SubScopes[current + i]));
    122121          creation.Add(ExecutionContext.CreateOperation(creator, CurrentScope.SubScopes[current + i]));
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs

    r9110 r9194  
    5555      get { return (IValueLookupParameter<IntValue>)Parameters["NumberToDelete"]; }
    5656    }
     57    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
     58      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
     59    }
    5760    #endregion
    5861
     
    7174      Parameters.Add(new ValueLookupParameter<BoolValue>("DoDeletion"));
    7275      Parameters.Add(new ValueLookupParameter<IntValue>("NumberToDelete"));
     76      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
    7377    }
    7478    public override IDeepCloneable Clone(Cloner cloner) {
     
    7781
    7882    public override IOperation Apply() {
    79       IItemSet<IClassifier> uniqueActions = new ItemSet<IClassifier>();
     83      IItemSet<IAction> uniqueActions = new ItemSet<IAction>(ClassifierComparerParameter.ActualValue);
    8084      var classifiers = ClassifiersParameter.ActualValue;
    8185      var matchcondition = MatchConditionParameter.ActualValue;
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs

    r9105 r9194  
    2626namespace HeuristicLab.Encodings.ConditionActionEncoding {
    2727  public interface ICovering : IStochasticOperator {
    28     ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter { get; }
    29     ILookupParameter<IItemSet<IClassifier>> PossibleActionsParameter { get; }
     28    ILookupParameter<IItemSet<IAction>> ActionsInMatchSetParameter { get; }
     29    ILookupParameter<IItemSet<IAction>> PossibleActionsParameter { get; }
    3030
    3131    ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter { get; }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs

    r9090 r9194  
    2828namespace HeuristicLab.Encodings.ConditionActionEncoding {
    2929  public interface ICoveringSolutionCreator : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable, IStochasticOperator {
    30     ILookupParameter<IClassifier> CoverClassifierParameter { get; }
    31     ILookupParameter<IClassifier> ActionParameter { get; }
     30    ILookupParameter<IInput> CoverInputParameter { get; }
     31    ILookupParameter<IAction> ActionParameter { get; }
    3232
    3333    IValueLookupParameter<IClassifier> CreatedClassifierParameter { get; }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/InsertInPopulationOperator.cs

    r9110 r9194  
    8686        IClassifier cl = classifiers[indices];
    8787        for (int i = 0; i < classifiers.Length; i++) {
    88           if (!hasToBeDeleted[i].Value && !insertInPopulation[i].Value && cl.Equals(classifiers[i])) {
     88          if (!hasToBeDeleted[i].Value && !insertInPopulation[i].Value && cl.Identical(classifiers[i])) {
    8989            numerosities[i].Value += numerosities[indices].Value;
    9090            hasToBeDeleted[indices].Value = true;
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj

    r9175 r9194  
    4343    </Reference>
    4444    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    45       <Private>False</Private>
    46     </Reference>
    47     <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    4845      <Private>False</Private>
    4946    </Reference>
     
    124121    <Compile Include="Reinforcement\IActionExecuter.cs" />
    125122    <Compile Include="Reinforcement\IClassifierFetcher.cs" />
    126     <Compile Include="Selectors\IMatchSelector.cs" />
    127     <Compile Include="Selectors\MatchSelector.cs" />
    128123    <Compile Include="Selectors\PreservingRightReducer.cs" />
    129124    <Compile Include="Subsumption\ActionSetSubsumptionOperator.cs" />
     
    140135    <None Include="Plugin.cs.frame" />
    141136  </ItemGroup>
    142   <ItemGroup />
     137  <ItemGroup>
     138    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
     139      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
     140      <Name>HeuristicLab.Core-3.3</Name>
     141    </ProjectReference>
     142  </ItemGroup>
    143143  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
    144144  <PropertyGroup>
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/IClassifier.cs

    r9175 r9194  
    2020#endregion
    2121
    22 using System;
     22using System.Collections.Generic;
    2323using HeuristicLab.Core;
    2424
    2525namespace HeuristicLab.Encodings.ConditionActionEncoding {
    26   /// <summary>
    27   /// IMatching is used in dictinoaries, therefore the methods "Equals" and "GetHashCode" have to be overriden
    28   /// IEquatable<IMatching> should be implemented as well.
    29   ///
    30   /// This also helps to implement macroclassifiers later on
    31   /// </summary>
    32   public interface IClassifier : IItem, IEquatable<IClassifier> {
    33     IClassifier Condition { get; }
    34     IClassifier Action { get; }
    35     bool MatchCondition(IClassifier target);
    36     bool MatchAction(IClassifier target);
     26  public interface IClassifier : IItem {
     27    ICondition Condition { get; }
     28    IAction Action { get; }
     29
     30    bool MatchInput(IInput target);
     31    bool MatchAction(IAction target);
    3732    bool IsMoreGeneral(IClassifier target);
     33    bool IsMoreGeneral(ICondition target);
    3834
    39     //to use IMatching as key in a dictionary, Equals and GetHashCode have to be override.
    40     //Also IEquatable<Class> should be implemented.
    41     bool Equals(object obj);
    42     int GetHashCode();
     35    bool Identical(IClassifier target);
    4336  }
     37
     38  public interface ICondition : IItem {
     39    bool Match(IInput target);
     40  }
     41
     42  public interface IAction : IItem {
     43    bool Match(IAction target);
     44  }
     45
     46  public interface IInput : IItem { }
     47
     48  public interface IClassifierComparer : IEqualityComparer<IAction>, IItem { }
    4449}
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionModel.cs

    r9161 r9194  
    2828
    2929    int ClassifierCount { get; }
    30     IEnumerable<IClassifier> GetAction(IEnumerable<IClassifier> classifiers);
    31     IClassifier GetAction(IClassifier classifier);
     30    IEnumerable<IAction> GetAction(IEnumerable<IInput> classifiers);
     31    IAction GetAction(IInput classifier);
    3232  }
    3333}
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs

    r9110 r9194  
    3737    //IItemSet<IClassifier> PossibleActions { get; }
    3838
     39    IParameter ClassifierComparerParameter { get; }
     40
    3941    ICoveringSolutionCreator CoveringSolutionCreator { get; }
    4042    IParameter CoveringSolutionCreatorParameter { get; }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblemData.cs

    r9161 r9194  
    4343    bool IsTestSample(int index);
    4444
    45     IEnumerable<IClassifier> FetchClassifier(IEnumerable<int> rows);
    46     IClassifier FetchClassifier(int rowNumber);
     45    IEnumerable<IInput> FetchInput(IEnumerable<int> rows);
     46    IInput FetchInput(int rowNumber);
     47
     48    IEnumerable<IAction> FetchAction(IEnumerable<int> rows);
     49    IAction FetchAction(int rowNumber);
    4750
    4851    event EventHandler Changed;
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs

    r9090 r9194  
    3535      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["Classifiers"]; }
    3636    }
    37     public IValueLookupParameter<IItemSet<IClassifier>> UniqueActionsParameter {
    38       get { return (IValueLookupParameter<IItemSet<IClassifier>>)Parameters["UniqueActions"]; }
     37    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
     38      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
     39    }
     40    public IValueLookupParameter<IItemSet<IAction>> UniqueActionsParameter {
     41      get { return (IValueLookupParameter<IItemSet<IAction>>)Parameters["UniqueActions"]; }
    3942    }
    4043    public IValueLookupParameter<IntValue> NumberOfUniqueActionsParameter {
     
    5356      : base() {
    5457      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
    55       Parameters.Add(new ValueLookupParameter<IItemSet<IClassifier>>("UniqueActions"));
     58      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
     59      Parameters.Add(new ValueLookupParameter<IItemSet<IAction>>("UniqueActions"));
    5660      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfUniqueActions"));
    5761    }
    5862
    5963    public override IOperation Apply() {
    60       ItemSet<IClassifier> actions = new ItemSet<IClassifier>();
     64      ItemSet<IAction> actions = new ItemSet<IAction>(ClassifierComparerParameter.ActualValue);
    6165      foreach (var classifier in ClassifiersParameter.ActualValue) {
    6266        actions.Add(classifier.Action);
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchActionOperator.cs

    r9089 r9194  
    3434      get { return (ILookupParameter<BoolValue>)Parameters["MatchAction"]; }
    3535    }
    36     public ILookupParameter<IClassifier> TargetMatchParameter {
    37       get { return (ILookupParameter<IClassifier>)Parameters["TargetMatchParameter"]; }
     36    public ILookupParameter<IAction> TargetMatchParameter {
     37      get { return (ILookupParameter<IAction>)Parameters["TargetMatchParameter"]; }
    3838    }
    3939    public ILookupParameter<IClassifier> MatchParameter {
     
    4949      : base() {
    5050      Parameters.Add(new LookupParameter<BoolValue>("MatchAction", "True if the action matches."));
    51       Parameters.Add(new ValueLookupParameter<IClassifier>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
     51      Parameters.Add(new ValueLookupParameter<IAction>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
    5252      Parameters.Add(new ValueLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
    5353    }
     
    5757
    5858    public override IOperation Apply() {
    59       IClassifier target = TargetMatchParameter.ActualValue;
     59      IAction target = TargetMatchParameter.ActualValue;
    6060      IClassifier match = MatchParameter.ActualValue;
    6161      MatchActionParameter.ActualValue = new BoolValue(match.MatchAction(target));
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs

    r9110 r9194  
    3434      get { return (ILookupParameter<BoolValue>)Parameters["MatchCondition"]; }
    3535    }
    36     public ILookupParameter<IClassifier> TargetMatchParameter {
    37       get { return (ILookupParameter<IClassifier>)Parameters["TargetMatchParameter"]; }
     36    public ILookupParameter<IInput> TargetMatchParameter {
     37      get { return (ILookupParameter<IInput>)Parameters["TargetMatchParameter"]; }
    3838    }
    3939    public ILookupParameter<IClassifier> MatchParameter {
     
    4949      : base() {
    5050      Parameters.Add(new LookupParameter<BoolValue>("MatchCondition", "True if the condition matches."));
    51       Parameters.Add(new ValueLookupParameter<IClassifier>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
     51      Parameters.Add(new ValueLookupParameter<IInput>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
    5252      Parameters.Add(new ValueLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
    5353    }
     
    5757
    5858    public override IOperation Apply() {
    59       IClassifier target = TargetMatchParameter.ActualValue;
     59      IInput target = TargetMatchParameter.ActualValue;
    6060      IClassifier match = MatchParameter.ActualValue;
    61       MatchConditionParameter.ActualValue = new BoolValue(match.MatchCondition(target));
     61      MatchConditionParameter.ActualValue = new BoolValue(match.MatchInput(target));
    6262      return base.Apply();
    6363    }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/PredictionArrayCalculator.cs

    r9089 r9194  
    3333  public class PredictionArrayCalculator : SingleSuccessorOperator {
    3434
     35    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
     36      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
     37    }
    3538    public ILookupParameter<ItemArray<DoubleValue>> FitnessParameter {
    3639      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Fitness"]; }
     
    3942      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Prediction"]; }
    4043    }
    41     public IValueParameter<IItemDictionary<IClassifier, DoubleValue>> PredictionArrayParameter {
    42       get { return (IValueParameter<IItemDictionary<IClassifier, DoubleValue>>)Parameters["PredictionArray"]; }
     44    public IValueParameter<IItemDictionary<IAction, DoubleValue>> PredictionArrayParameter {
     45      get { return (IValueParameter<IItemDictionary<IAction, DoubleValue>>)Parameters["PredictionArray"]; }
    4346    }
    4447    public ILookupParameter<ItemArray<IClassifier>> MatchParameter {
     
    5356    public PredictionArrayCalculator()
    5457      : base() {
     58      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
    5559      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Fitness"));
    5660      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Prediction"));
    57       Parameters.Add(new ValueLookupParameter<IItemDictionary<IClassifier, DoubleValue>>("PredictionArray"));
     61      Parameters.Add(new ValueLookupParameter<IItemDictionary<IAction, DoubleValue>>("PredictionArray"));
    5862      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which sub-scopes should be selected."));
    5963      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
     
    6468
    6569    public sealed override IOperation Apply() {
    66       IItemDictionary<IClassifier, DoubleValue> predictionArray = new ItemDictionary<IClassifier, DoubleValue>();
    67       IDictionary<IClassifier, double> fitnessSumPerAction = new Dictionary<IClassifier, double>();
     70      IItemDictionary<IAction, DoubleValue> predictionArray = new ItemDictionary<IAction, DoubleValue>(ClassifierComparerParameter.ActualValue);
     71      IDictionary<IAction, double> fitnessSumPerAction = new Dictionary<IAction, double>(ClassifierComparerParameter.ActualValue);
    6872      ItemArray<DoubleValue> fitnesses = FitnessParameter.ActualValue;
    6973      ItemArray<DoubleValue> predictions = PredictionParameter.ActualValue;
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ActionExecuter.cs

    r9175 r9194  
    3333
    3434    #region parameter
    35     public IValueLookupParameter<IClassifier> SelectedActionParameter {
    36       get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
     35    public IValueLookupParameter<IAction> SelectedActionParameter {
     36      get { return (IValueLookupParameter<IAction>)Parameters["SelectedAction"]; }
    3737    }
    38     public IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter {
    39       get { return (IValueLookupParameter<IClassifier>)Parameters["CurrentClassifierToMatch"]; }
     38    public IValueLookupParameter<IAction> CurrentActionToMatchParameter {
     39      get { return (IValueLookupParameter<IAction>)Parameters["CurrentActionToMatch"]; }
    4040    }
    4141    public IValueLookupParameter<DoubleValue> CurrentPayoffParameter {
     
    6161    public ActionExecuter()
    6262      : base() {
    63       Parameters.Add(new ValueLookupParameter<IClassifier>("SelectedAction"));
    64       Parameters.Add(new ValueLookupParameter<IClassifier>("CurrentClassifierToMatch"));
     63      Parameters.Add(new ValueLookupParameter<IAction>("SelectedAction"));
     64      Parameters.Add(new ValueLookupParameter<IAction>("CurrentActionToMatch"));
    6565      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentPayoff"));
    6666      Parameters.Add(new ValueLookupParameter<DoubleValue>("NegativeReward"));
     
    6969
    7070    public override IOperation Apply() {
    71       if (SelectedActionParameter.ActualValue.MatchAction(CurrentClassifierToMatchParameter.ActualValue)) {
     71      if (SelectedActionParameter.ActualValue.Match(CurrentActionToMatchParameter.ActualValue)) {
    7272        CurrentPayoffParameter.ActualValue = PositiveRewardParameter.ActualValue;
    7373      } else {
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ClassifierFetcher.cs

    r9161 r9194  
    3333  [StorableClass]
    3434  public class ClassifierFetcher : SingleSuccessorOperator, IClassifierFetcher {
     35
    3536    #region parameters
    36     public IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter {
    37       get { return (IValueLookupParameter<IClassifier>)Parameters["CurrentClassifierToMatch"]; }
     37    public IValueLookupParameter<IInput> CurrentInputToMatchParameter {
     38      get { return (IValueLookupParameter<IInput>)Parameters["CurrentConditionToMatch"]; }
     39    }
     40    public IValueLookupParameter<IAction> CurrentActionToMatchParameter {
     41      get { return (IValueLookupParameter<IAction>)Parameters["CurrentActionToMatch"]; }
    3842    }
    3943    public ILookupParameter<IConditionActionProblemData> ProblemDataParameter {
     
    5660    public ClassifierFetcher()
    5761      : base() {
    58       Parameters.Add(new ValueLookupParameter<IClassifier>("CurrentClassifierToMatch"));
     62      Parameters.Add(new ValueLookupParameter<IInput>("CurrentConditionToMatch"));
     63      Parameters.Add(new ValueLookupParameter<IAction>("CurrentActionToMatch"));
    5964      Parameters.Add(new LookupParameter<IConditionActionProblemData>("ProblemData"));
    6065      Parameters.Add(new LookupParameter<IntValue>("Iteration"));
     
    6873      var trainingIndices = ProblemData.TrainingIndices.ToList();
    6974      int index = IterationParameter.ActualValue.Value % trainingIndices.Count;
    70       CurrentClassifierToMatchParameter.ActualValue = ProblemDataParameter.ActualValue.FetchClassifier(trainingIndices[index]);
     75      CurrentInputToMatchParameter.ActualValue = ProblemDataParameter.ActualValue.FetchInput(trainingIndices[index]);
     76      CurrentActionToMatchParameter.ActualValue = ProblemDataParameter.ActualValue.FetchAction(trainingIndices[index]);
    7177      return base.Apply();
    7278    }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IActionExecuter.cs

    r9089 r9194  
    2727namespace HeuristicLab.Encodings.ConditionActionEncoding {
    2828  public interface IActionExecuter : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
    29     IValueLookupParameter<IClassifier> SelectedActionParameter { get; }
    30     IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter { get; }
     29    IValueLookupParameter<IAction> SelectedActionParameter { get; }
     30    IValueLookupParameter<IAction> CurrentActionToMatchParameter { get; }
    3131    IValueLookupParameter<DoubleValue> CurrentPayoffParameter { get; }
    3232    ILookupParameter<DoubleValue> NegativeRewardParameter { get; }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IClassifierFetcher.cs

    r9089 r9194  
    2727namespace HeuristicLab.Encodings.ConditionActionEncoding {
    2828  public interface IClassifierFetcher : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
    29     IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter { get; }
     29    IValueLookupParameter<IInput> CurrentInputToMatchParameter { get; }
     30    IValueLookupParameter<IAction> CurrentActionToMatchParameter { get; }
    3031    ILookupParameter<IConditionActionProblemData> ProblemDataParameter { get; }
    3132    ILookupParameter<IntValue> IterationParameter { get; }
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/CheckGASubsumptionOperator.cs

    r9110 r9194  
    105105      for (int i = 0; i < parents.Length; i++) {
    106106        IClassifier curParent = parents[i];
    107         if (curParent.MatchAction(child)) {
     107        if (curParent.MatchAction(child.Action)) {
    108108          if (CouldSubsume(experiences[i], errors[i])) {
    109109            if (curParent.IsMoreGeneral(child)) {
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSModel.cs

    r9161 r9194  
    3434    public int ClassifierCount { get { return Count; } }
    3535
     36    public IClassifierComparer ClassifierComparer { get; set; }
     37
    3638    [StorableConstructor]
    3739    protected XCSModel(bool deserializing) : base(deserializing) { }
     
    5153    }
    5254
    53     public IEnumerable<IClassifier> GetAction(IEnumerable<IClassifier> classifiers) {
     55    public IEnumerable<IAction> GetAction(IEnumerable<IInput> classifiers) {
    5456      foreach (var classifier in classifiers) {
    5557        yield return GetAction(classifier);
     
    5759    }
    5860
    59     public IClassifier GetAction(IClassifier classifier) {
     61    public IAction GetAction(IInput classifier) {
    6062      var matchedClassifiers = new ItemCollection<XCSClassifier>();
    6163      foreach (var xcsClassifier in this) {
    62         if (xcsClassifier.Classifier.MatchCondition(classifier)) {
     64        if (xcsClassifier.Classifier.MatchInput(classifier)) {
    6365          matchedClassifiers.Add(xcsClassifier);
    6466        }
     
    6769      if (matchedClassifiers.Count == 0) { return null; }
    6870
    69       IDictionary<IClassifier, double> predictionArray = CreatePredictionArray(matchedClassifiers);
     71      IDictionary<IAction, double> predictionArray = CreatePredictionArray(matchedClassifiers);
    7072      return predictionArray.OrderByDescending(x => x.Value).First().Key;
    7173    }
    7274
    73     private IDictionary<IClassifier, double> CreatePredictionArray(ItemCollection<XCSClassifier> matchedClassifiers) {
    74       var predictionArray = new Dictionary<IClassifier, double>();
    75       var fitnessSumPerAction = new Dictionary<IClassifier, double>();
     75    private IDictionary<IAction, double> CreatePredictionArray(ItemCollection<XCSClassifier> matchedClassifiers) {
     76      var predictionArray = new Dictionary<IAction, double>(ClassifierComparer);
     77      var fitnessSumPerAction = new Dictionary<IAction, double>(ClassifierComparer);
    7678
    7779      foreach (var xcsClassifier in matchedClassifiers) {
     
    8688      }
    8789
    88       var actions = new List<IClassifier>(predictionArray.Keys);
     90      var actions = new List<IAction>(predictionArray.Keys);
    8991      foreach (var action in actions) {
    9092        if (fitnessSumPerAction[action] != 0) {
  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSSolution.cs

    r9175 r9194  
    104104
    105105    private void RecalculateResults() {
    106       var originalTrainingClassifer = ProblemData.FetchClassifier(ProblemData.TrainingIndices);
    107       var originalTestClassifer = ProblemData.FetchClassifier(ProblemData.TestIndices);
    108       var estimatedTrainingClassifier = Model.GetAction(originalTrainingClassifer);
    109       var estimatedTestClassifier = Model.GetAction(originalTestClassifer);
    110 
    111       TrainingAccuracy = CalculateAccuracy(originalTrainingClassifer, estimatedTrainingClassifier);
    112       TestAccuracy = CalculateAccuracy(originalTestClassifer, estimatedTestClassifier);
    113     }
    114 
    115     private double CalculateAccuracy(IEnumerable<IClassifier> original, IEnumerable<IClassifier> estimated) {
     106      var originalTrainingCondition = ProblemData.FetchInput(ProblemData.TrainingIndices);
     107      var originalTestCondition = ProblemData.FetchInput(ProblemData.TestIndices);
     108      var estimatedTrainingClassifier = Model.GetAction(originalTrainingCondition);
     109      var estimatedTestClassifier = Model.GetAction(originalTestCondition);
     110
     111      var originalTrainingAction = ProblemData.FetchAction(ProblemData.TrainingIndices);
     112      var originalTestAction = ProblemData.FetchAction(ProblemData.TestIndices);
     113
     114      TrainingAccuracy = CalculateAccuracy(originalTrainingAction, estimatedTrainingClassifier);
     115      TestAccuracy = CalculateAccuracy(originalTestAction, estimatedTestClassifier);
     116    }
     117
     118    private double CalculateAccuracy(IEnumerable<IAction> original, IEnumerable<IAction> estimated) {
    116119      double correctClassified = 0;
    117120
     
    121124
    122125      while (originalEnumerator.MoveNext() && estimatedActionEnumerator.MoveNext()) {
    123         if (originalEnumerator.Current.MatchAction(estimatedActionEnumerator.Current)) {
     126        if (originalEnumerator.Current.Match(estimatedActionEnumerator.Current)) {
    124127          correctClassified++;
    125128        }
  • branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj

    r9160 r9194  
    4444    <Reference Include="HeuristicLab.Common-3.3">
    4545      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
    46       <Private>False</Private>
    47     </Reference>
    48     <Reference Include="HeuristicLab.Core-3.3">
    49       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
    5046      <Private>False</Private>
    5147    </Reference>
     
    10096  </ItemGroup>
    10197  <ItemGroup>
     98    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
     99      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
     100      <Name>HeuristicLab.Core-3.3</Name>
     101    </ProjectReference>
    102102    <ProjectReference Include="..\..\HeuristicLab.Encodings.CombinedIntegerVectorEncoding\3.3\HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj">
    103103      <Project>{CE7163C5-BFFE-45F0-9BD0-E10EF24E8BD2}</Project>
  • branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs

    r9175 r9194  
    6969      get { return (IFixedValueParameter<DoubleValue>)Parameters["InitialFitness"]; }
    7070    }
    71     public IFixedValueParameter<ItemSet<IClassifier>> PossibleActionsParameter {
    72       get { return (IFixedValueParameter<ItemSet<IClassifier>>)Parameters["PossibleActions"]; }
     71    public IFixedValueParameter<ItemSet<IAction>> PossibleActionsParameter {
     72      get { return (IFixedValueParameter<ItemSet<IAction>>)Parameters["PossibleActions"]; }
    7373    }
    7474    public IFixedValueParameter<ItemSet<CombinedIntegerVector>> PossibleActionsConcreteClassParameter {
     
    7777    public IFixedValueParameter<IntValue> ThetaMinimalNumberOfActionsParameter {
    7878      get { return (IFixedValueParameter<IntValue>)Parameters["ThetaMinimalNumberOfActions"]; }
     79    }
     80    public IFixedValueParameter<HeuristicLab.Encodings.CombinedIntegerVectorEncoding.CombinedIntegerVector.CombinedIntegerVectorComparer> ClassifierComparerParameter {
     81      get { return (IFixedValueParameter<HeuristicLab.Encodings.CombinedIntegerVectorEncoding.CombinedIntegerVector.CombinedIntegerVectorComparer>)Parameters["ClassifierComparer"]; }
    7982    }
    8083    #endregion
     
    108111    //  get { return PossibleActions; }
    109112    //}
    110     public ItemSet<IClassifier> PossibleActions {
     113    public ItemSet<IAction> PossibleActions {
    111114      get { return PossibleActionsParameter.Value; }
    112115    }
     
    148151    IParameter IConditionActionProblem.CoveringSolutionCreatorParameter {
    149152      get { return CoveringSolutionCreatorParameter; }
     153    }
     154    public IClassifierComparer ClassifierComparer {
     155      get { return ClassifierComparerParameter.Value; }
     156    }
     157    IParameter IConditionActionProblem.ClassifierComparerParameter {
     158      get { return ClassifierComparerParameter; }
    150159    }
    151160    #endregion
     
    177186      Parameters.Add(new ValueParameter<IActionExecuter>(ActionExecuterParameterName, "", new ActionExecuter()));
    178187      Parameters.Add(new ValueParameter<ClassifierFetcher>(ClassifierFetcherParameterName, "", new ClassifierFetcher()));
    179       Parameters.Add(new FixedValueParameter<ItemSet<IClassifier>>("PossibleActions"));
    180       Parameters.Add(new FixedValueParameter<ItemSet<CombinedIntegerVector>>("PossibleActionsConcreteClass"));
     188      Parameters.Add(new FixedValueParameter<HeuristicLab.Encodings.CombinedIntegerVectorEncoding.CombinedIntegerVector.CombinedIntegerVectorComparer>("ClassifierComparer", new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.CombinedIntegerVector.CombinedIntegerVectorComparer()));
     189      Parameters.Add(new FixedValueParameter<ItemSet<IAction>>("PossibleActions", new ItemSet<IAction>(ClassifierComparer)));
     190      Parameters.Add(new FixedValueParameter<ItemSet<CombinedIntegerVector>>("PossibleActionsConcreteClass", new ItemSet<CombinedIntegerVector>(ClassifierComparer)));
    181191      Parameters.Add(new FixedValueParameter<IntValue>("ThetaMinimalNumberOfActions", "Minimal number of actions, which have to be present in the match set, or else covering will occure.", new IntValue(1)));
    182192
     
    191201
    192202      coveringSolutionCreator.ChangeSymbolProbabilityParameter.ActualName = ChangeSymbolProbabilityInCoveringParameter.Name;
    193       coveringSolutionCreator.CoverClassifierParameter.ActualName = ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
     203      coveringSolutionCreator.CoverInputParameter.ActualName = ClassifierFetcher.CurrentInputToMatchParameter.ActualName;
    194204      coveringSolutionCreator.CreatedClassifierParameter.ActualName = "CombinedIntegerVector";
    195205
    196206      ClassifierFetcher.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
    197207
    198       ActionExecuter.CurrentClassifierToMatchParameter.ActualName = ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
     208      ActionExecuter.CurrentActionToMatchParameter.ActualName = ClassifierFetcher.CurrentActionToMatchParameter.ActualName;
    199209      ActionExecuter.NegativeRewardParameter.ActualName = NegativeRewardParameter.Name;
    200210      ActionExecuter.PositiveRewardParameter.ActualName = PositiveRewardParameter.Name;
     
    241251        xcsAnalyzer.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
    242252        xcsAnalyzer.ResultsParameter.ActualName = "Results";
     253        xcsAnalyzer.ClassifierComparerParameter.ActualName = ClassifierComparerParameter.Name;
    243254      }
    244255    }
  • branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblemData.cs

    r9167 r9194  
    119119    #endregion
    120120
    121     private IDictionary<int, IClassifier> fetchClassifiersCache = new Dictionary<int, IClassifier>();
    122 
    123 
    124121    [StorableConstructor]
    125122    protected ConditionActionClassificationProblemData(bool deserializing) : base(deserializing) { }
     
    201198    }
    202199
    203     public IEnumerable<IClassifier> FetchClassifier(IEnumerable<int> rows) {
     200    public IEnumerable<IInput> FetchInput(IEnumerable<int> rows) {
    204201      foreach (var row in rows) {
    205         yield return FetchClassifier(row);
    206       }
    207     }
    208 
    209     public IClassifier FetchClassifier(int rowNumber) {
     202        yield return FetchInput(row);
     203      }
     204    }
     205    public IInput FetchInput(int rowNumber) {
     206      return FetchClassifier(rowNumber).Condition as IInput;
     207    }
     208    public IEnumerable<IAction> FetchAction(IEnumerable<int> rows) {
     209      foreach (var row in rows) {
     210        yield return FetchAction(row);
     211      }
     212    }
     213    public IAction FetchAction(int rowNumber) {
     214      return FetchClassifier(rowNumber).Action;
     215    }
     216    #region fetchHelper
     217    private IDictionary<int, IClassifier> fetchClassifiersCache = new Dictionary<int, IClassifier>();
     218
     219    private IClassifier FetchClassifier(int rowNumber) {
    210220      if (!fetchClassifiersCache.ContainsKey(rowNumber)) {
    211221        int[] elements = new int[Length.Value];
     
    231241      return fetchClassifiersCache[rowNumber];
    232242    }
     243    #endregion
    233244  }
    234245}
  • branches/LearningClassifierSystems/HeuristicLab.Problems.Instances.ConditionActionClassification/3.3/HeuristicLab.Problems.Instances.ConditionActionClassification.csproj

    r9160 r9194  
    3939  <ItemGroup>
    4040    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
    41     <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
    4241    <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
    4342    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
     
    6766  </ItemGroup>
    6867  <ItemGroup>
     68    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
     69      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
     70      <Name>HeuristicLab.Core-3.3</Name>
     71    </ProjectReference>
    6972    <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
    7073      <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
  • branches/LearningClassifierSystems/HeuristicLab.Problems.XCS.Views/3.3/HeuristicLab.Problems.XCS.Views-3.3.csproj

    r9154 r9194  
    4141    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
    4242    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
    43     <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
    4443    <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
    4544    <Reference Include="HeuristicLab.MainForm-3.3">
     
    7877  </ItemGroup>
    7978  <ItemGroup>
     79    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
     80      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
     81      <Name>HeuristicLab.Core-3.3</Name>
     82    </ProjectReference>
    8083    <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
    8184      <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
  • branches/LearningClassifierSystems/LearningClassifierSystem.sln

    r9160 r9194  
    1919EndProject
    2020Project("{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}"
     21EndProject
     22Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Core-3.3", "HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj", "{C36BD924-A541-4A00-AFA8-41701378DDC5}"
     23EndProject
     24Project("{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}"
    2125EndProject
    2226Global
     
    8286    {1CC7585E-DD22-41FA-869B-93DE41EA8936}.Release|x64.ActiveCfg = Release|Any CPU
    8387    {1CC7585E-DD22-41FA-869B-93DE41EA8936}.Release|x86.ActiveCfg = Release|Any CPU
     88    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     89    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|Any CPU.Build.0 = Debug|Any CPU
     90    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|x64.ActiveCfg = Debug|x64
     91    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|x64.Build.0 = Debug|x64
     92    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|x86.ActiveCfg = Debug|x86
     93    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|x86.Build.0 = Debug|x86
     94    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|Any CPU.ActiveCfg = Release|Any CPU
     95    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|Any CPU.Build.0 = Release|Any CPU
     96    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|x64.ActiveCfg = Release|x64
     97    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|x64.Build.0 = Release|x64
     98    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|x86.ActiveCfg = Release|x86
     99    {C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|x86.Build.0 = Release|x86
     100    {7C116F48-7218-4105-BD6E-EE868E2D4823}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     101    {7C116F48-7218-4105-BD6E-EE868E2D4823}.Debug|Any CPU.Build.0 = Debug|Any CPU
     102    {7C116F48-7218-4105-BD6E-EE868E2D4823}.Debug|x64.ActiveCfg = Debug|Any CPU
     103    {7C116F48-7218-4105-BD6E-EE868E2D4823}.Debug|x86.ActiveCfg = Debug|Any CPU
     104    {7C116F48-7218-4105-BD6E-EE868E2D4823}.Release|Any CPU.ActiveCfg = Release|Any CPU
     105    {7C116F48-7218-4105-BD6E-EE868E2D4823}.Release|Any CPU.Build.0 = Release|Any CPU
     106    {7C116F48-7218-4105-BD6E-EE868E2D4823}.Release|x64.ActiveCfg = Release|Any CPU
     107    {7C116F48-7218-4105-BD6E-EE868E2D4823}.Release|x86.ActiveCfg = Release|Any CPU
    84108  EndGlobalSection
    85109  GlobalSection(SolutionProperties) = preSolution
Note: See TracChangeset for help on using the changeset viewer.