Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
12/20/11 13:54:57 (13 years ago)
Author:
spimming
Message:

#1680:

  • merged changes from trunk into branch

' removed pre-build event for multiple app.configs

Location:
branches/HeuristicLab.Hive.Azure
Files:
4 deleted
8 edited
1 copied

Legend:

Unmodified
Added
Removed

  • branches/HeuristicLab.Hive.Azure

  • branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAnalyzer.cs

    r5882 r7215  
    2020#endregion
    2121
    22 using System.Collections.Generic;
    23 using System.Linq;
    2422using HeuristicLab.Common;
    2523using HeuristicLab.Core;
    26 using HeuristicLab.Data;
    2724using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2825using HeuristicLab.Operators;
     26using HeuristicLab.Optimization;
    2927using HeuristicLab.Parameters;
    3028using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    31 using HeuristicLab.Optimization;
    3229
    3330namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    … …  
    4946    #endregion
    5047    #region properties
     48    public virtual bool EnabledByDefault {
     49      get { return true; }
     50    }
    5151    public ItemArray<ISymbolicExpressionTree> SymbolicExpressionTree {
    5252      get { return SymbolicExpressionTreeParameter.ActualValue; }

  • branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationAnalyzer.cs

    r5882 r7215  
    2020#endregion
    2121
     22using System;
     23using System.Collections.Generic;
    2224using System.Linq;
    2325using HeuristicLab.Common;
    … …  
    2628using HeuristicLab.Parameters;
    2729using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    28 using System.Collections.Generic;
    29 using System;
    3030using HeuristicLab.Random;
    3131

  • branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

    r6975 r7215  
    5858        constants.Clear();
    5959        strBuilder.AppendLine("% needs \\usepackage{amsmath}");
    60         strBuilder.AppendLine("\\begin{align}");
     60        strBuilder.AppendLine("\\begin{align*}");
     61        strBuilder.AppendLine("\\nonumber");
    6162        strBuilder.AppendLine(FormatRecursively(symbolicExpressionTree.Root));
    62         strBuilder.AppendLine("\\end{align}");
     63        strBuilder.AppendLine("\\end{align*}");
    6364        return strBuilder.ToString();
    6465      }
    … …  
    7677        strBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    7778      }
     79      int i = 1;
    7880      foreach (SymbolicExpressionTreeNode subTree in node.Subtrees.Skip(1)) {
    79         FormatSep(node, strBuilder);
     81        FormatSep(node, strBuilder, i);
    8082        // format the whole subtree
    8183        strBuilder.Append(FormatRecursively(subTree));
     84        i++;
    8285      }
    8386
    … …  
    8992    private void FormatBegin(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
    9093      if (node.Symbol is Addition) {
    91         strBuilder.Append(@" \left( ");
     94        strBuilder.Append(@" ( ");
    9295      } else if (node.Symbol is Subtraction) {
    9396        if (node.SubtreeCount == 1) {
    94           strBuilder.Append(@"- \left(");
     97          strBuilder.Append(@"- ( ");
    9598        } else {
    96           strBuilder.Append(@" \left( ");
     99          strBuilder.Append(@" ( ");
    97100        }
    98101      } else if (node.Symbol is Multiplication) {
    … …  
    108111          strBuilder.Append(@" \cfrac{1}{" + node.SubtreeCount + @"}");
    109112        }
    110         strBuilder.Append(@" \left(");
     113        strBuilder.Append(@" ( ");
    111114      } else if (node.Symbol is Logarithm) {
    112         strBuilder.Append(@"\log \left(");
     115        strBuilder.Append(@"\log ( ");
    113116      } else if (node.Symbol is Exponential) {
    114         strBuilder.Append(@"\exp \left(");
     117        strBuilder.Append(@"\exp ( ");
    115118      } else if (node.Symbol is Sine) {
    116         strBuilder.Append(@"\sin \left(");
     119        strBuilder.Append(@"\sin ( ");
    117120      } else if (node.Symbol is Cosine) {
    118         strBuilder.Append(@"\cos \left(");
     121        strBuilder.Append(@"\cos ( ");
    119122      } else if (node.Symbol is Tangent) {
    120         strBuilder.Append(@"\tan \left(");
     123        strBuilder.Append(@"\tan ( ");
    121124      } else if (node.Symbol is GreaterThan) {
    122         strBuilder.Append(@" \left( ");
     125        strBuilder.Append(@"  ( ");
    123126      } else if (node.Symbol is LessThan) {
    124         strBuilder.Append(@" \left( ");
     127        strBuilder.Append(@"  ( ");
    125128      } else if (node.Symbol is And) {
    126         strBuilder.Append(@" \left( \left( ");
     129        strBuilder.Append(@"   ( ");
    127130      } else if (node.Symbol is Or) {
    128         strBuilder.Append(@" \left( \left( ");
     131        strBuilder.Append(@"   ( ");
    129132      } else if (node.Symbol is Not) {
    130         strBuilder.Append(@" \neg \left( ");
     133        strBuilder.Append(@" \neg ( ");
    131134      } else if (node.Symbol is IfThenElse) {
    132         strBuilder.Append(@"\left( \operatorname{if} \left( 0 < ");
     135        strBuilder.Append(@" \operatorname{if}  ( 0 < ");
    133136      } else if (node.Symbol is Constant) {
    134137        strBuilder.Append("c_{" + constants.Count + "} ");
    … …  
    137140      } else if (node.Symbol is LaggedVariable) {
    138141        var laggedVarNode = node as LaggedVariableTreeNode;
    139         strBuilder.Append("c_{" + constants.Count + "} " + EscapeLatexString(laggedVarNode.VariableName));
     142        if (!laggedVarNode.Weight.IsAlmost(1.0)) {
     143          strBuilder.Append("c_{" + constants.Count + "} \\cdot ");
     144          constants.Add(laggedVarNode.Weight);
     145        }
     146        strBuilder.Append(EscapeLatexString(laggedVarNode.VariableName));
    140147        strBuilder.Append(LagToString(currentLag + laggedVarNode.Lag));
    141         constants.Add(laggedVarNode.Weight);
    142       } else if (node.Symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Variable) {
     148
     149      } else if (node.Symbol is Variable) {
    143150        var varNode = node as VariableTreeNode;
    144         strBuilder.Append("c_{" + constants.Count + "} " + EscapeLatexString(varNode.VariableName));
     151        if (!varNode.Weight.IsAlmost((1.0))) {
     152          strBuilder.Append("c_{" + constants.Count + "} \\cdot ");
     153          constants.Add(varNode.Weight);
     154        }
     155        strBuilder.Append(EscapeLatexString(varNode.VariableName));
    145156        strBuilder.Append(LagToString(currentLag));
    146         constants.Add(varNode.Weight);
    147157      } else if (node.Symbol is ProgramRootSymbol) {
    148158      } else if (node.Symbol is Defun) {
    … …  
    151161      } else if (node.Symbol is InvokeFunction) {
    152162        var invokeNode = node as InvokeFunctionTreeNode;
    153         strBuilder.Append(invokeNode.Symbol.FunctionName + @" \left( ");
     163        strBuilder.Append(invokeNode.Symbol.FunctionName + @" ( ");
    154164      } else if (node.Symbol is StartSymbol) {
    155165        strBuilder.Append("Result & = ");
    … …  
    158168        strBuilder.Append(" ARG+" + argSym.ArgumentIndex + " ");
    159169      } else if (node.Symbol is Derivative) {
    160         strBuilder.Append(@" \cfrac{d \left(");
     170        strBuilder.Append(@" \cfrac{d ( ");
    161171      } else if (node.Symbol is TimeLag) {
    162172        var laggedNode = node as ILaggedTreeNode;
    163173        currentLag += laggedNode.Lag;
    164174      } else if (node.Symbol is Power) {
    165         strBuilder.Append(@"\left(");
     175        strBuilder.Append(@" ( ");
    166176      } else if (node.Symbol is Root) {
    167         strBuilder.Append(@"\left(");
     177        strBuilder.Append(@" ( ");
    168178      } else if (node.Symbol is Integral) {
    169179        // actually a new variable for t is needed in all subtrees (TODO)
    170180        var laggedTreeNode = node as ILaggedTreeNode;
    171         strBuilder.Append(@"\sum_{t=" + (laggedTreeNode.Lag + currentLag) + @"}^0 \left(");
     181        strBuilder.Append(@"\sum_{t=" + (laggedTreeNode.Lag + currentLag) + @"}^0 ( ");
    172182      } else if (node.Symbol is VariableCondition) {
    173183        var conditionTreeNode = node as VariableConditionTreeNode;
    174         string p = @"1 / \left( 1 + \exp \left( - c_{" + constants.Count + "} ";
     184        string p = @"1 /  1 + \exp - c_{" + constants.Count + "} ";
    175185        constants.Add(conditionTreeNode.Slope);
    176         p += @" \cdot \left(" + EscapeLatexString(conditionTreeNode.VariableName) + LagToString(currentLag) + " - c_{" + constants.Count + @"} \right) \right) \right)";
     186        p += @" \cdot " + EscapeLatexString(conditionTreeNode.VariableName) + LagToString(currentLag) + " - c_{" + constants.Count + @"}   ";
    177187        constants.Add(conditionTreeNode.Threshold);
    178         strBuilder.Append(@"\left( " + p + @"\cdot ");
     188        strBuilder.Append(@" ( " + p + @"\cdot ");
    179189      } else {
    180190        throw new NotImplementedException("Export of " + node.Symbol + " is not implemented.");
    … …  
    182192    }
    183193
    184     private void FormatSep(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
     194    private void FormatSep(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, int step) {
    185195      if (node.Symbol is Addition) {
    186196        strBuilder.Append(" + ");
    … …  
    190200        strBuilder.Append(@" \cdot ");
    191201      } else if (node.Symbol is Division) {
    192         strBuilder.Append(@" }{ \cfrac{ ");
     202        if (step + 1 == node.SubtreeCount)
     203          strBuilder.Append(@"}{");
     204        else
     205          strBuilder.Append(@" }{ \cfrac{ ");
    193206      } else if (node.Symbol is Average) {
    194207        strBuilder.Append(@" + ");
    … …  
    208221        strBuilder.Append(@" < ");
    209222      } else if (node.Symbol is And) {
    210         strBuilder.Append(@" > 0 \right) \land \left(");
     223        strBuilder.Append(@" > 0  ) \land (");
    211224      } else if (node.Symbol is Or) {
    212         strBuilder.Append(@" > 0 \right) \lor \left(");
     225        strBuilder.Append(@" > 0  ) \lor (");
    213226      } else if (node.Symbol is Not) {
    214227        throw new InvalidOperationException();
    215228      } else if (node.Symbol is IfThenElse) {
    216         strBuilder.Append(@" \right) , \left(");
     229        strBuilder.Append(@" ) , (");
    217230      } else if (node.Symbol is ProgramRootSymbol) {
    218231        strBuilder.Append(@"\\" + Environment.NewLine);
    … …  
    223236        strBuilder.Append(@"\\" + Environment.NewLine + " & ");
    224237      } else if (node.Symbol is Power) {
    225         strBuilder.Append(@"\right) ^ { \operatorname{round} \left(");
     238        strBuilder.Append(@") ^ { \operatorname{round} (");
    226239      } else if (node.Symbol is Root) {
    227         strBuilder.Append(@"\right) ^ { \left( \cfrac{1}{ \operatorname{round} \left(");
     240        strBuilder.Append(@") ^ {  \cfrac{1}{ \operatorname{round} (");
    228241      } else if (node.Symbol is VariableCondition) {
    229242        var conditionTreeNode = node as VariableConditionTreeNode;
    230         string p = @"1 / \left( 1 + \exp \left( - c_{" + constants.Count + "} ";
     243        string p = @"1 / ( 1 + \exp ( - c_{" + constants.Count + "} ";
    231244        constants.Add(conditionTreeNode.Slope);
    232         p += @" \cdot \left(" + EscapeLatexString(conditionTreeNode.VariableName) + LagToString(currentLag) + " - c_{" + constants.Count + @"} \right) \right) \right)";
     245        p += @" \cdot " + EscapeLatexString(conditionTreeNode.VariableName) + LagToString(currentLag) + " - c_{" + constants.Count + @"} ) ) )   ";
    233246        constants.Add(conditionTreeNode.Threshold);
    234         strBuilder.Append(@" + \left( 1 - " + p + @" \right) \cdot ");
     247        strBuilder.Append(@" +  ( 1 - " + p + @" ) \cdot ");
    235248      } else {
    236249        throw new NotImplementedException("Export of " + node.Symbol + " is not implemented.");
    … …  
    240253    private void FormatEnd(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
    241254      if (node.Symbol is Addition) {
    242         strBuilder.Append(@" \right) ");
     255        strBuilder.Append(@" ) ");
    243256      } else if (node.Symbol is Subtraction) {
    244         strBuilder.Append(@" \right) ");
     257        strBuilder.Append(@" ) ");
    245258      } else if (node.Symbol is Multiplication) {
    246259      } else if (node.Symbol is Division) {
    247         strBuilder.Append("} ");
    248         if (node.SubtreeCount > 1)
    249           strBuilder.Append("{1} ");
    250         for (int i = 1; i < node.SubtreeCount; i++) {
     260        strBuilder.Append(" } ");
     261        for (int i = 2; i < node.SubtreeCount; i++)
    251262          strBuilder.Append(" } ");
    252         }
    253263      } else if (node.Symbol is Average) {
    254         strBuilder.Append(@" \right)");
     264        strBuilder.Append(@" ) ");
    255265      } else if (node.Symbol is Logarithm) {
    256         strBuilder.Append(@" \right) ");
     266        strBuilder.Append(@" ) ");
    257267      } else if (node.Symbol is Exponential) {
    258         strBuilder.Append(@" \right) ");
     268        strBuilder.Append(@" ) ");
    259269      } else if (node.Symbol is Sine) {
    260         strBuilder.Append(@" \right) ");
     270        strBuilder.Append(@" ) ");
    261271      } else if (node.Symbol is Cosine) {
    262         strBuilder.Append(@" \right) ");
     272        strBuilder.Append(@" ) ");
    263273      } else if (node.Symbol is Tangent) {
    264         strBuilder.Append(@" \right) ");
     274        strBuilder.Append(@" ) ");
    265275      } else if (node.Symbol is GreaterThan) {
    266         strBuilder.Append(@" \right) ");
     276        strBuilder.Append(@" ) ");
    267277      } else if (node.Symbol is LessThan) {
    268         strBuilder.Append(@" \right) ");
     278        strBuilder.Append(@" ) ");
    269279      } else if (node.Symbol is And) {
    270         strBuilder.Append(@" > 0 \right) \right) ");
     280        strBuilder.Append(@" > 0 ) ) ");
    271281      } else if (node.Symbol is Or) {
    272         strBuilder.Append(@" > 0 \right) \right) ");
     282        strBuilder.Append(@" > 0 ) ) ");
    273283      } else if (node.Symbol is Not) {
    274         strBuilder.Append(@" \right) ");
     284        strBuilder.Append(@" ) ");
    275285      } else if (node.Symbol is IfThenElse) {
    276         strBuilder.Append(@" \right) \right) ");
     286        strBuilder.Append(@" ) ) ");
    277287      } else if (node.Symbol is Constant) {
    278288      } else if (node.Symbol is LaggedVariable) {
    279       } else if (node.Symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Variable) {
     289      } else if (node.Symbol is Variable) {
    280290      } else if (node.Symbol is ProgramRootSymbol) {
    281291        // output all constant values
    … …  
    290300      } else if (node.Symbol is Defun) {
    291301      } else if (node.Symbol is InvokeFunction) {
    292         strBuilder.Append(@" \right) ");
     302        strBuilder.Append(@" ) ");
    293303      } else if (node.Symbol is StartSymbol) {
    294304      } else if (node.Symbol is Argument) {
    295305      } else if (node.Symbol is Derivative) {
    296         strBuilder.Append(@" \right) }{dt} ");
     306        strBuilder.Append(@" ) }{dt} ");
    297307      } else if (node.Symbol is TimeLag) {
    298308        var laggedNode = node as ILaggedTreeNode;
    299309        currentLag -= laggedNode.Lag;
    300310      } else if (node.Symbol is Power) {
    301         strBuilder.Append(@"\right) } ");
     311        strBuilder.Append(@" ) } ");
    302312      } else if (node.Symbol is Root) {
    303         strBuilder.Append(@"\right) } \right) } ");
     313        strBuilder.Append(@" ) } ) } ");
    304314      } else if (node.Symbol is Integral) {
    305315        var laggedTreeNode = node as ILaggedTreeNode;
    306         strBuilder.Append(@"\right) ");
     316        strBuilder.Append(@" ) ");
    307317      } else if (node.Symbol is VariableCondition) {
    308318        strBuilder.Append(@"\left) ");
    … …  
    317327      } else if (lag > 0) {
    318328        return "(t+" + lag + ")";
    319       } else return "(t)";
     329      } else return "";
    320330    }
    321331

  • branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs

    r6819 r7215  
    138138
    139139      AddAllowedChildSymbol(powerSymbols, variableSymbol, 0);
     140      AddAllowedChildSymbol(powerSymbols, laggedVariable, 0);
    140141      AddAllowedChildSymbol(powerSymbols, constant, 1);
    141142
    … …  
    187188    public void ConfigureAsDefaultClassificationGrammar() {
    188189      Symbols.Where(s => s is Average).First().Enabled = false;
     190      Symbols.Where(s => s is VariableCondition).First().Enabled = false;
    189191      Symbols.Where(s => s.Name == TrigonometricFunctionsName).First().Enabled = false;
    190192      Symbols.Where(s => s.Name == ExponentialFunctionsName).First().Enabled = false;
    … …  
    192194      Symbols.Where(s => s.Name == TimeSeriesSymbolsName).First().Enabled = false;
    193195    }
    194 
    195     public void ConfigureAsDefaultTimeSeriesPrognosisGrammar() {
    196       Symbols.Where(s => s is Variable).First().Enabled = false;
    197       Symbols.Where(s => s.Name == TrigonometricFunctionsName).First().Enabled = false;
    198       Symbols.Where(s => s.Name == PowerFunctionsName).First().Enabled = false;
    199       Symbols.Where(s => s.Name == ConditionalSymbolsName).First().Enabled = false;
    200     }
    201196  }
    202197}

  • branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

    r6888 r7215  
    121121    <Compile Include="Analyzers\SymbolicDataAnalysisVariableFrequencyAnalyzer.cs" />
    122122    <Compile Include="Analyzers\SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs" />
    123     <Compile Include="SymbolicDataAnalysisExpressionFullTreeCreator.cs" />
     123    <Compile Include="Creators\MultiSymbolicDataAnalysisExpressionCreator.cs" />
     124    <Compile Include="Creators\SymbolicDataAnalysisExpressionFullTreeCreator.cs" />
     125    <Compile Include="Creators\SymbolicDataAnalysisExpressionGrowTreeCreator.cs" />
     126    <Compile Include="Creators\SymbolicDataAnalysisExpressionRampedHalfAndHalfTreeCreator.cs" />
     127    <Compile Include="Creators\SymbolicDataAnalysisExpressionTreeCreator.cs" />
    124128    <Compile Include="Plugin.cs" />
    125     <Compile Include="SymbolicDataAnalysisExpressionGrowTreeCreator.cs" />
    126     <Compile Include="SymbolicDataAnalysisExpressionRampedHalfAndHalfTreeCreator.cs" />
    127129    <Compile Include="SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs" />
    128130    <Compile Include="Formatters\SymbolicDataAnalysisExpressionLatexFormatter.cs" />
    … …  
    131133    <Compile Include="Interfaces\ISymbolicDataAnalysisExpressionTreeInterpreter.cs" />
    132134    <Compile Include="Interfaces\ISymbolicDataAnalysisProblem.cs" />
    133     <Compile Include="SymbolicDataAnalysisExpressionTreeCreator.cs" />
    134135    <Compile Include="SymbolicDataAnalysisModel.cs">
    135136      <SubType>Code</SubType>

  • branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

    r6849 r7215  
    584584        //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
    585585        case OpCodes.VariableCondition: {
    586             throw new NotImplementedException();
    587           }
    588         default: throw new NotSupportedException();
     586            throw new NotSupportedException("Interpretation of symbol " + currentInstr.dynamicNode.Symbol.Name + " is not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter");
     587          }
     588        default: throw new NotSupportedException("Interpretation of symbol " + currentInstr.dynamicNode.Symbol.Name + " is not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter");
    589589      }
    590590    }

  • branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs

    r6978 r7215  
    169169      Parameters.Add(new FixedValueParameter<PercentValue>(RelativeNumberOfEvaluatedSamplesParameterName, RelativeNumberOfEvaluatedSamplesParameterDescription, new PercentValue(1)));
    170170
    171       SolutionCreatorParameter.Hidden = true;
    172171      SymbolicExpressionTreeInterpreterParameter.Hidden = true;
    173172      MaximumFunctionArgumentsParameter.Hidden = true;
Note: See TracChangeset for help on using the changeset viewer.