Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
09/14/11 13:59:25 (13 years ago)
Author:
epitzer
Message:

#1530 integrate changes from trunk

Location:
branches/PersistenceSpeedUp
Files:
13 edited
1 copied

Legend:

Unmodified
Added
Removed

  • branches/PersistenceSpeedUp

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs

    r6135 r6760  
    2020#endregion
    2121
    22 using System;
     22using System.Collections.Generic;
    2323using System.Linq;
     24using System.Text;
    2425using HeuristicLab.Analysis;
    2526using HeuristicLab.Common;
    2627using HeuristicLab.Core;
    2728using HeuristicLab.Data;
     29using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2830using HeuristicLab.Parameters;
    2931using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    30 using System.Collections.Generic;
    31 using System.Text;
    32 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    3332
    3433namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    … …  
    4746    }
    4847
    49     public IValueParameter<IntValue> AlleleTreeDepthParameter {
     48    public IFixedValueParameter<IntValue> AlleleTreeDepthParameter {
    5049      get { return (IFixedValueParameter<IntValue>)Parameters[AlleleTreeDepthParameterName]; }
    5150    }
    … …  
    7170
    7271    protected override Allele[] CalculateAlleles(ISymbolicExpressionTree solution) {
    73       List<Allele> alleles = new List<Allele>();
    74 
    75       foreach (var subtree in GetAllSubtreesOfDepth(solution, AlleleTreeDepth)) {
    76         alleles.Add(GetAlleleFromSubtreeOfDepth(subtree, AlleleTreeDepth));
    77       }
    78       return alleles.ToArray();
     72      return GetAllSubtreesOfDepth(solution, AlleleTreeDepth)
     73        .AsParallel()
     74        .Select(t => GetAlleleFromSubtreeOfDepth(t, AlleleTreeDepth))
     75        .ToArray();
    7976    }
    8077

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisMultiObjectiveValidationBestSolutionAnalyzer.cs

    r5907 r6760  
    9393      IList<int> nonDominatedIndexes = new List<int>();
    9494      ISymbolicExpressionTree[] tree = SymbolicExpressionTree.ToArray();
    95       List<double[]> qualities = new List<double[]>();
    9695      bool[] maximization = Maximization.ToArray();
    9796      List<double[]> newNonDominatedQualities = new List<double[]>();
    9897      var evaluator = EvaluatorParameter.ActualValue;
     98      var problemData = ProblemDataParameter.ActualValue;
    9999      IExecutionContext childContext = (IExecutionContext)ExecutionContext.CreateChildOperation(evaluator);
     100
     101      var qualities = tree
     102        .AsParallel()
     103        .Select(t => evaluator.Evaluate(childContext, t, problemData, rows))
     104        .ToArray();
    100105      for (int i = 0; i < tree.Length; i++) {
    101         qualities.Add(evaluator.Evaluate(childContext, tree[i], ProblemDataParameter.ActualValue, rows)); // qualities[i] = ...
    102106        if (IsNonDominated(qualities[i], trainingBestQualities, maximization) &&
    103107          IsNonDominated(qualities[i], qualities, maximization)) {

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationBestSolutionAnalyzer.cs

    r5907 r6760  
    7676      ISymbolicExpressionTree bestTree = null;
    7777      ISymbolicExpressionTree[] tree = SymbolicExpressionTree.ToArray();
    78       double[] quality = new double[tree.Length];
    7978      var evaluator = EvaluatorParameter.ActualValue;
     79      var problemData = ProblemDataParameter.ActualValue;
    8080      IEnumerable<int> rows = GenerateRowsToEvaluate();
    8181      if (!rows.Any()) return base.Apply();
    8282
    8383      IExecutionContext childContext = (IExecutionContext)ExecutionContext.CreateChildOperation(evaluator);
     84      var quality = tree
     85        .AsParallel()
     86        .Select(t => evaluator.Evaluate(childContext, t, problemData, rows))
     87        .ToArray();
     88
    8489      for (int i = 0; i < tree.Length; i++) {
    85         quality[i] = evaluator.Evaluate(childContext, tree[i], ProblemDataParameter.ActualValue, rows);
    8690        if (IsBetter(quality[i], bestQuality, Maximization.Value)) {
    8791          bestQuality = quality[i];

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisVariableFrequencyAnalyzer.cs

    r5924 r6760  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
    2324using System.Linq;
    … …  
    104105          datatable.Rows.Add(row);
    105106        }
    106         datatable.Rows[pair.Key].Values.Add(pair.Value);
     107        datatable.Rows[pair.Key].Values.Add(Math.Round(pair.Value, 3));
    107108      }
    108109
    … …  
    130131
    131132    public static IEnumerable<KeyValuePair<string, double>> CalculateVariableFrequencies(IEnumerable<ISymbolicExpressionTree> trees, bool aggregateLaggedVariables = true) {
    132       Dictionary<string, double> variableFrequencies = new Dictionary<string, double>();
    133       int totalNumberOfSymbols = 0;
    134 
    135       foreach (var tree in trees) {
    136         var variableReferences = GetVariableReferences(tree, aggregateLaggedVariables);
    137         foreach (var pair in variableReferences) {
    138           totalNumberOfSymbols += pair.Value;
    139           if (variableFrequencies.ContainsKey(pair.Key)) {
    140             variableFrequencies[pair.Key] += pair.Value;
    141           } else {
    142             variableFrequencies.Add(pair.Key, pair.Value);
    143           }
    144         }
    145       }
     133
     134      var variableFrequencies = trees
     135        .AsParallel()
     136        .SelectMany(t => GetVariableReferences(t, aggregateLaggedVariables))
     137        .GroupBy(pair => pair.Key, pair => pair.Value)
     138        .ToDictionary(g => g.Key, g => (double)g.Sum());
     139
     140      double totalNumberOfSymbols = variableFrequencies.Values.Sum();
    146141
    147142      foreach (var pair in variableFrequencies)

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

    r6135 r6760  
    121121    <Compile Include="Analyzers\SymbolicDataAnalysisVariableFrequencyAnalyzer.cs" />
    122122    <Compile Include="Analyzers\SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs" />
     123    <Compile Include="SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs" />
    123124    <Compile Include="Formatters\SymbolicDataAnalysisExpressionLatexFormatter.cs" />
    124125    <Compile Include="Formatters\SymbolicDataAnalysisExpressionMATLABFormatter.cs" />

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLabProblemsDataAnalysisSymbolicPlugin.cs.frame

    r5860 r6760  
    2626
    2727namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    28   [Plugin("HeuristicLab.Problems.DataAnalysis.Symbolic","Provides base classes for symbolic data analysis tasks.", "3.4.0.$WCREV$")]
     28  [Plugin("HeuristicLab.Problems.DataAnalysis.Symbolic","Provides base classes for symbolic data analysis tasks.", "3.4.1.$WCREV$")]
    2929  [PluginFile("HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.dll", PluginFileType.Assembly)]
    3030  [PluginDependency("HeuristicLab.Analysis", "3.3")]

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Properties/AssemblyInfo.frame

    r5860 r6760  
    5353// by using the '*' as shown below:
    5454[assembly: AssemblyVersion("3.4.0.0")]
    55 [assembly: AssemblyFileVersion("3.4.0.$WCREV$")]
     55[assembly: AssemblyFileVersion("3.4.1.$WCREV$")]

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeInterpreter.cs

    r5987 r6760  
    2424using HeuristicLab.Common;
    2525using HeuristicLab.Core;
     26using HeuristicLab.Data;
    2627using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     28using HeuristicLab.Parameters;
    2729using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    28 using HeuristicLab.Data;
    29 using HeuristicLab.Parameters;
    3030
    3131namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    … …  
    208208        if (instr.opCode == OpCodes.Variable) {
    209209          var variableTreeNode = instr.dynamicNode as VariableTreeNode;
    210           instr.iArg0 = (ushort)dataset.GetVariableIndex(variableTreeNode.VariableName);
     210          instr.iArg0 = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
    211211          code[i] = instr;
    212212        } else if (instr.opCode == OpCodes.LagVariable) {
    213           var variableTreeNode = instr.dynamicNode as LaggedVariableTreeNode;
    214           instr.iArg0 = (ushort)dataset.GetVariableIndex(variableTreeNode.VariableName);
     213          var laggedVariableTreeNode = instr.dynamicNode as LaggedVariableTreeNode;
     214          instr.iArg0 = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
    215215          code[i] = instr;
    216216        } else if (instr.opCode == OpCodes.VariableCondition) {
    217217          var variableConditionTreeNode = instr.dynamicNode as VariableConditionTreeNode;
    218           instr.iArg0 = (ushort)dataset.GetVariableIndex(variableConditionTreeNode.VariableName);
     218          instr.iArg0 = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
    219219        } else if (instr.opCode == OpCodes.Call) {
    220220          necessaryArgStackSize += instr.nArguments + 1;
    … …  
    308308            double result = Evaluate(dataset, ref row, state);
    309309            for (int i = 1; i < currentInstr.nArguments; i++) {
    310               if (result <= 0.0) SkipInstructions(state);
     310              if (result > 0.0) result = Evaluate(dataset, ref row, state);
    311311              else {
    312                 result = Evaluate(dataset, ref row, state);
     312                SkipInstructions(state);
    313313              }
    314314            }
    315             return result <= 0.0 ? -1.0 : 1.0;
     315            return result > 0.0 ? 1.0 : -1.0;
    316316          }
    317317        case OpCodes.OR: {
    318318            double result = Evaluate(dataset, ref row, state);
    319319            for (int i = 1; i < currentInstr.nArguments; i++) {
    320               if (result > 0.0) SkipInstructions(state);
     320              if (result <= 0.0) result = Evaluate(dataset, ref row, state);
    321321              else {
    322                 result = Evaluate(dataset, ref row, state);
     322                SkipInstructions(state);
    323323              }
    324324            }
    … …  
    390390            int savedPc = state.ProgramCounter;
    391391            // set pc to start of function 
    392             state.ProgramCounter = currentInstr.iArg0;
     392            state.ProgramCounter = (ushort)currentInstr.iArg0;
    393393            // evaluate the function
    394394            double v = Evaluate(dataset, ref row, state);
    … …  
    402402          }
    403403        case OpCodes.Arg: {
    404             return state.GetStackFrameValue(currentInstr.iArg0);
     404            return state.GetStackFrameValue((ushort)currentInstr.iArg0);
    405405          }
    406406        case OpCodes.Variable: {
    407407            if (row < 0 || row >= dataset.Rows)
    408408              return double.NaN;
    409             var variableTreeNode = currentInstr.dynamicNode as VariableTreeNode;
    410             return dataset[row, currentInstr.iArg0] * variableTreeNode.Weight;
     409            var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
     410            return ((IList<double>)currentInstr.iArg0)[row] * variableTreeNode.Weight;
    411411          }
    412412        case OpCodes.LagVariable: {
    413             var laggedVariableTreeNode = currentInstr.dynamicNode as LaggedVariableTreeNode;
     413            var laggedVariableTreeNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
    414414            int actualRow = row + laggedVariableTreeNode.Lag;
    415415            if (actualRow < 0 || actualRow >= dataset.Rows)
    416416              return double.NaN;
    417             return dataset[actualRow, currentInstr.iArg0] * laggedVariableTreeNode.Weight;
     417            return ((IList<double>)currentInstr.iArg0)[row] * laggedVariableTreeNode.Weight;
    418418          }
    419419        case OpCodes.Constant: {
    … …  
    428428              return double.NaN;
    429429            var variableConditionTreeNode = (VariableConditionTreeNode)currentInstr.dynamicNode;
    430             double variableValue = dataset[row, currentInstr.iArg0];
     430            double variableValue = ((IList<double>)currentInstr.iArg0)[row];
    431431            double x = variableValue - variableConditionTreeNode.Threshold;
    432432            double p = 1 / (1 + Math.Exp(-variableConditionTreeNode.Slope * x));

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs

    r6135 r6760  
    202202      Operators.Add(new SymbolicDataAnalysisVariableFrequencyAnalyzer());
    203203      Operators.Add(new MinAverageMaxSymbolicExpressionTreeLengthAnalyzer());
    204       Operators.Add(new SymbolicDataAnalysisAlleleFrequencyAnalyzer());
    205204      ParameterizeOperators();
    206205    }

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSingleObjectiveProblem.cs

    r5847 r6760  
    7979
    8080      MaximizationParameter.Hidden = true;
     81      InitializeOperators();
    8182      RegisterEventHandler();
    8283    }
    … …  
    8586    private void AfterDeserialization() {
    8687      RegisterEventHandler();
     88    }
     89
     90    private void InitializeOperators() {
     91      Operators.Add(new SymbolicDataAnalysisAlleleFrequencyAnalyzer());
     92      ParameterizeOperators();
    8793    }
    8894

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tests/Properties/AssemblyInfo.cs

    r5809 r6760  
    5252// by using the '*' as shown below:
    5353[assembly: AssemblyVersion("3.4.0.0")]
    54 [assembly: AssemblyFileVersion("3.4.0.0")]
     54[assembly: AssemblyFileVersion("3.4.1.0")]

  • branches/PersistenceSpeedUp/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tests/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs

    r5809 r6760  
    3030
    3131
    32   /// <summary>
    33   ///This is a test class for SimpleArithmeticExpressionInterpreter and is intended
    34   ///to contain all SimpleArithmeticExpressionInterpreter Unit Tests
    35   ///</summary>
    3632  [TestClass()]
    3733  public class SymbolicDataAnalysisExpressionTreeInterpreterTest {
    … …  
    5551
    5652    [TestMethod]
    57     public void FullGrammarSimpleArithmeticExpressionInterpreterPerformanceTest() {
     53    public void SymbolicDataAnalysisExpressionTreeInterpreterFullGrammarPerformanceTest() {
     54      FullGrammarPerformanceTest(new SymbolicDataAnalysisExpressionTreeInterpreter(), 12.5e6);
     55    }
     56    [TestMethod]
     57    public void SymbolicDataAnalysisExpressionTreeInterpreterArithmeticGrammarPerformanceTest() {
     58      FullGrammarPerformanceTest(new SymbolicDataAnalysisExpressionTreeInterpreter(), 12.5e6);
     59    }
     60
     61    [TestMethod]
     62    public void SymbolicDataAnalysisExpressionTreeILEmittingInterpreterFullGrammarPerformanceTest() {
     63      FullGrammarPerformanceTest(new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(), 10e6);
     64    }
     65    [TestMethod]
     66    public void SymbolicDataAnalysisExpressionTreeILEmittingInterpreterArithmeticGrammarPerformanceTest() {
     67      FullGrammarPerformanceTest(new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(), 10e6);
     68    }
     69
     70    private void FullGrammarPerformanceTest(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, double nodesPerSecThreshold) {
    5871      var twister = new MersenneTwister(31415);
    5972      var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
    … …  
    6477      grammar.MinimumFunctionDefinitions = 0;
    6578      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
    66       double[] estimation = new double[Rows];
    6779      foreach (ISymbolicExpressionTree tree in randomTrees) {
    6880        Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
    6981      }
    70       SymbolicDataAnalysisExpressionTreeInterpreter interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
    7182      double nodesPerSec = Util.CalculateEvaluatedNodesPerSec(randomTrees, interpreter, dataset, 3);
    72       Assert.IsTrue(nodesPerSec > 12.5e6); // evaluated nodes per seconds must be larger than 15mNodes/sec
    73     }
    74 
    75     [TestMethod]
    76     public void ArithmeticGrammarSimpleArithmeticExpressionInterpreterPerformanceTest() {
     83      Assert.IsTrue(nodesPerSec > nodesPerSecThreshold); // evaluated nodes per seconds must be larger than 15mNodes/sec
     84    }
     85
     86    private void ArithmeticGrammarPerformanceTest(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, double nodesPerSecThreshold) {
    7787      var twister = new MersenneTwister(31415);
    7888      var dataset = Util.CreateRandomDataset(twister, Rows, Columns);
    … …  
    8393      grammar.MinimumFunctionDefinitions = 0;
    8494      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
    85       double[] estimation = new double[Rows];
    8695      foreach (SymbolicExpressionTree tree in randomTrees) {
    8796        Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
    8897      }
    89       SymbolicDataAnalysisExpressionTreeInterpreter interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
     98
    9099      double nodesPerSec = Util.CalculateEvaluatedNodesPerSec(randomTrees, interpreter, dataset, 3);
    91       Assert.IsTrue(nodesPerSec > 12.5e6); // evaluated nodes per seconds must be larger than 15mNodes/sec
     100      Assert.IsTrue(nodesPerSec > nodesPerSecThreshold); // evaluated nodes per seconds must be larger than 15mNodes/sec
    92101    }
    93102
    … …  
    97106    ///</summary>
    98107    [TestMethod]
    99     public void SimpleArithmeticExpressionInterpreterEvaluateTest() {
    100 
     108    public void SymbolicDataAnalysisExpressionTreeInterpreterEvaluateTest() {
    101109      Dataset ds = new Dataset(new string[] { "Y", "A", "B" }, new double[,] {
    102110        { 1.0, 1.0, 1.0 },
    … …  
    105113      });
    106114
    107       SymbolicDataAnalysisExpressionTreeInterpreter interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
    108 
     115      var interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
     116      EvaluateTerminals(interpreter, ds);
     117      EvaluateOperations(interpreter, ds);
     118      EvaluateAdf(interpreter, ds);
     119    }
     120
     121    [TestMethod]
     122    public void SymbolicDataAnalysisExpressionILEmittingTreeInterpreterEvaluateTest() {
     123      Dataset ds = new Dataset(new string[] { "Y", "A", "B" }, new double[,] {
     124        { 1.0, 1.0, 1.0 },
     125        { 2.0, 2.0, 2.0 },
     126        { 3.0, 1.0, 2.0 }
     127      });
     128
     129      var interpreter = new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter();
     130      EvaluateTerminals(interpreter, ds);
     131      EvaluateOperations(interpreter, ds);
     132    }
     133
     134    private void EvaluateTerminals(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, Dataset ds) {
    109135      // constants
    110136      Evaluate(interpreter, ds, "(+ 1.5 3.5)", 0, 5.0);
    … …  
    113139      Evaluate(interpreter, ds, "(variable 2.0 a)", 0, 2.0);
    114140      Evaluate(interpreter, ds, "(variable 2.0 a)", 1, 4.0);
    115 
    116 
     141    }
     142
     143    private void EvaluateAdf(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, Dataset ds) {
     144
     145      // ADF     
     146      Evaluate(interpreter, ds, @"(PROG
     147                                    (MAIN
     148                                      (CALL ADF0))
     149                                    (defun ADF0 1.0))", 1, 1.0);
     150      Evaluate(interpreter, ds, @"(PROG
     151                                    (MAIN
     152                                      (* (CALL ADF0) (CALL ADF0)))
     153                                    (defun ADF0 2.0))", 1, 4.0);
     154      Evaluate(interpreter, ds, @"(PROG
     155                                    (MAIN
     156                                      (CALL ADF0 2.0 3.0))
     157                                    (defun ADF0
     158                                      (+ (ARG 0) (ARG 1))))", 1, 5.0);
     159      Evaluate(interpreter, ds, @"(PROG
     160                                    (MAIN (CALL ADF1 2.0 3.0))
     161                                    (defun ADF0
     162                                      (- (ARG 1) (ARG 0)))
     163                                    (defun ADF1
     164                                      (+ (CALL ADF0 (ARG 1) (ARG 0))
     165                                         (CALL ADF0 (ARG 0) (ARG 1)))))", 1, 0.0);
     166      Evaluate(interpreter, ds, @"(PROG
     167                                    (MAIN (CALL ADF1 (variable 2.0 a) 3.0))
     168                                    (defun ADF0
     169                                      (- (ARG 1) (ARG 0)))
     170                                    (defun ADF1                                                                             
     171                                      (CALL ADF0 (ARG 1) (ARG 0))))", 1, 1.0);
     172      Evaluate(interpreter, ds,
     173               @"(PROG
     174                                    (MAIN (CALL ADF1 (variable 2.0 a) 3.0))
     175                                    (defun ADF0
     176                                      (- (ARG 1) (ARG 0)))
     177                                    (defun ADF1                                                                             
     178                                      (+ (CALL ADF0 (ARG 1) (ARG 0))
     179                                         (CALL ADF0 (ARG 0) (ARG 1)))))", 1, 0.0);
     180    }
     181
     182    private void EvaluateOperations(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, Dataset ds) {
    117183      // addition
    118184      Evaluate(interpreter, ds, "(+ (variable 2.0 a ))", 1, 4.0);
    … …  
    148214      Evaluate(interpreter, ds, "(> (variable 2.0 a) 1.9)", 0, 1.0);
    149215      Evaluate(interpreter, ds, "(> 1.9 (variable 2.0 a))", 0, -1.0);
    150       //Evaluate(interpreter, ds, "(> (sqrt -1.0) (log -1.0))", 0, -1.0); // (> nan nan) should be false
     216      Evaluate(interpreter, ds, "(> (log -1.0) (log -1.0))", 0, -1.0); // (> nan nan) should be false
    151217
    152218      // lt
    … …  
    155221      Evaluate(interpreter, ds, "(< (variable 2.0 a) 1.9)", 0, -1.0);
    156222      Evaluate(interpreter, ds, "(< 1.9 (variable 2.0 a))", 0, 1.0);
    157       //Evaluate(interpreter, ds, "(< (sqrt -1,0) (log -1,0))", 0, -1.0); // (< nan nan) should be false
     223      Evaluate(interpreter, ds, "(< (log -1.0) (log -1.0))", 0, -1.0); // (< nan nan) should be false
    158224
    159225      // If
    … …  
    163229      Evaluate(interpreter, ds, "(if 1.0 2.0 3.0)", 0, 2.0);
    164230      Evaluate(interpreter, ds, "(if 10.0 2.0 3.0)", 0, 2.0);
    165       // Evaluate(interpreter, ds, "(if (sqrt -1.0) 2.0 3.0)", 0, 3.0); // if(nan) should return the else branch
     231      Evaluate(interpreter, ds, "(if (log -1.0) 2.0 3.0)", 0, 3.0); // if(nan) should return the else branch
    166232
    167233      // NOT
    … …  
    171237      Evaluate(interpreter, ds, "(not 2.0)", 0, -1.0);
    172238      Evaluate(interpreter, ds, "(not 0.0)", 0, 1.0);
     239      Evaluate(interpreter, ds, "(not (log -1.0))", 0, 1.0);
    173240
    174241      // AND
    … …  
    181248      Evaluate(interpreter, ds, "(and 1.0 2.0 3.0)", 0, 1.0);
    182249      Evaluate(interpreter, ds, "(and 1.0 -2.0 3.0)", 0, -1.0);
     250      Evaluate(interpreter, ds, "(and (log -1.0))", 0, -1.0); // (and NaN)
     251      Evaluate(interpreter, ds, "(and (log -1.0)  1.0)", 0, -1.0); // (and NaN 1.0)
     252
    183253
    184254      // OR
    … …  
    190260      Evaluate(interpreter, ds, "(or -1.0 -2.0 -3.0)", 0, -1.0);
    191261      Evaluate(interpreter, ds, "(or -1.0 -2.0 3.0)", 0, 1.0);
     262      Evaluate(interpreter, ds, "(or (log -1.0))", 0, -1.0); // (or NaN)
     263      Evaluate(interpreter, ds, "(or (log -1.0)  1.0)", 0, -1.0); // (or NaN 1.0)
    192264
    193265      // sin, cos, tan
    … …  
    204276      Evaluate(interpreter, ds, "(log -3.0)", 0, Math.Log(-3));
    205277
     278      // power
     279      Evaluate(interpreter, ds, "(pow 2.0 3.0)", 0, 8.0);
     280      Evaluate(interpreter, ds, "(pow 4.0 0.5)", 0, 1.0); // interpreter should round to the nearest integer value value (.5 is rounded to the even number)
     281      Evaluate(interpreter, ds, "(pow 4.0 2.5)", 0, 16.0); // interpreter should round to the nearest integer value value (.5 is rounded to the even number)
     282      Evaluate(interpreter, ds, "(pow -2.0 3.0)", 0, -8.0);
     283      Evaluate(interpreter, ds, "(pow 2.0 -3.0)", 0, 1.0 / 8.0);
     284      Evaluate(interpreter, ds, "(pow -2.0 -3.0)", 0, -1.0 / 8.0);
     285
     286      // root
     287      Evaluate(interpreter, ds, "(root 9.0 2.0)", 0, 3.0);
     288      Evaluate(interpreter, ds, "(root 27.0 3.0)", 0, 3.0);
     289      Evaluate(interpreter, ds, "(root 2.0 -3.0)", 0, Math.Pow(2.0, -1.0 / 3.0));
     290
    206291      // mean
    207292      Evaluate(interpreter, ds, "(mean -1.0 1.0 -1.0)", 0, -1.0 / 3.0);
    208293
    209       // ADF     
    210       Evaluate(interpreter, ds, @"(PROG
    211                                     (MAIN
    212                                       (CALL ADF0))
    213                                     (defun ADF0 1.0))", 1, 1.0);
    214       Evaluate(interpreter, ds, @"(PROG
    215                                     (MAIN
    216                                       (* (CALL ADF0) (CALL ADF0)))
    217                                     (defun ADF0 2.0))", 1, 4.0);
    218       Evaluate(interpreter, ds, @"(PROG
    219                                     (MAIN
    220                                       (CALL ADF0 2.0 3.0))
    221                                     (defun ADF0
    222                                       (+ (ARG 0) (ARG 1))))", 1, 5.0);
    223       Evaluate(interpreter, ds, @"(PROG
    224                                     (MAIN (CALL ADF1 2.0 3.0))
    225                                     (defun ADF0
    226                                       (- (ARG 1) (ARG 0)))
    227                                     (defun ADF1
    228                                       (+ (CALL ADF0 (ARG 1) (ARG 0))
    229                                          (CALL ADF0 (ARG 0) (ARG 1)))))", 1, 0.0);
    230       Evaluate(interpreter, ds, @"(PROG
    231                                     (MAIN (CALL ADF1 (variable 2.0 a) 3.0))
    232                                     (defun ADF0
    233                                       (- (ARG 1) (ARG 0)))
    234                                     (defun ADF1                                                                             
    235                                       (CALL ADF0 (ARG 1) (ARG 0))))", 1, 1.0);
    236       Evaluate(interpreter, ds, @"(PROG
    237                                     (MAIN (CALL ADF1 (variable 2.0 a) 3.0))
    238                                     (defun ADF0
    239                                       (- (ARG 1) (ARG 0)))
    240                                     (defun ADF1                                                                             
    241                                       (+ (CALL ADF0 (ARG 1) (ARG 0))
    242                                          (CALL ADF0 (ARG 0) (ARG 1)))))", 1, 0.0);
    243     }
    244 
    245     private void Evaluate(SymbolicDataAnalysisExpressionTreeInterpreter interpreter, Dataset ds, string expr, int index, double expected) {
     294    }
     295
     296    private void Evaluate(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, Dataset ds, string expr, int index, double expected) {
    246297      var importer = new SymbolicExpressionImporter();
    247298      ISymbolicExpressionTree tree = importer.Import(expr);
Note: See TracChangeset for help on using the changeset viewer.