Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/02/16 14:38:40 (8 years ago)
Author:
gkronber
Message:

#2591: merged r13438 (#2541), r13721, r13724, r13784, r13891 from trunk to stable

Location:
stable
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • stable

  • stable/HeuristicLab.Algorithms.DataAnalysis

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceConst.cs

    r12009 r13981  
    2121
    2222using System;
    23 using System.Collections.Generic;
    24 using System.Linq;
    2523using HeuristicLab.Common;
    2624using HeuristicLab.Core;
    … …  
    8381    }
    8482
    85     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     83    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    8684      double scale;
    8785      GetParameterValues(p, out scale);
    … …  
    9189      cov.CrossCovariance = (x, xt, i, j) => scale;
    9290      if (HasFixedScaleParameter) {
    93         cov.CovarianceGradient = (x, i, j) => Enumerable.Empty<double>();
     91        cov.CovarianceGradient = (x, i, j) => new double[0];
    9492      } else {
    95         cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, scale, columnIndices);
     93        cov.CovarianceGradient = (x, i, j) => new[] { 2.0 * scale };
    9694      }
    9795      return cov;
    9896    }
    99 
    100     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double scale, IEnumerable<int> columnIndices) {
    101       yield return 2.0 * scale;
    102     }
    10397  }
    10498}

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinear.cs

    r12009 r13981  
    2121
    2222using System;
    23 using System.Collections.Generic;
    24 using System.Linq;
    2523using HeuristicLab.Common;
    2624using HeuristicLab.Core;
    … …  
    5250    }
    5351
    54     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     52    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    5553      if (p.Length > 0) throw new ArgumentException("No parameters are allowed for the linear covariance function.");
    5654      // create functions
    5755      var cov = new ParameterizedCovarianceFunction();
    58       cov.Covariance = (x, i, j) => Util.ScalarProd(x, i, j, 1, columnIndices);
    59       cov.CrossCovariance = (x, xt, i, j) =>  Util.ScalarProd(x, i, xt, j, 1.0 , columnIndices);
    60       cov.CovarianceGradient = (x, i, j) => Enumerable.Empty<double>();
     56      cov.Covariance = (x, i, j) => Util.ScalarProd(x, i, j, columnIndices, 1.0);
     57      cov.CrossCovariance = (x, xt, i, j) => Util.ScalarProd(x, i, xt, j, columnIndices, 1.0);
     58      cov.CovarianceGradient = (x, i, j) => new double[0];
    6159      return cov;
    6260    }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinearArd.cs

    r12009 r13981  
    8181    }
    8282
    83     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     83    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    8484      double[] inverseLength;
    8585      GetParameterValues(p, out inverseLength);
    … …  
    9090      cov.CrossCovariance = (x, xt, i, j) => Util.ScalarProd(x, i, xt, j, inverseLength, columnIndices);
    9191      if (fixedInverseLength)
    92         cov.CovarianceGradient = (x, i, j) => Enumerable.Empty<double>();
     92        cov.CovarianceGradient = (x, i, j) => new double[0];
    9393      else
    9494        cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, inverseLength, columnIndices);
    … …  
    9696    }
    9797
    98     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double[] inverseLength, IEnumerable<int> columnIndices) {
     98    private static IList<double> GetGradient(double[,] x, int i, int j, double[] inverseLength, int[] columnIndices) {
    9999      int k = 0;
    100       foreach (int columnIndex in columnIndices) {
    101         yield return -2.0 * x[i, columnIndex] * x[j, columnIndex] * inverseLength[k] * inverseLength[k];
     100      var g = new List<double>(columnIndices.Length);
     101      for (int c = 0; c < columnIndices.Length; c++) {
     102        var columnIndex = columnIndices[c];
     103        g.Add(-2.0 * x[i, columnIndex] * x[j, columnIndex] * inverseLength[k] * inverseLength[k]);
    102104        k++;
    103105      }
     106      return g;
    104107    }
    105108  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceMask.cs

    r12009 r13981  
    2020#endregion
    2121
    22 using System;
    23 using System.Collections.Generic;
    2422using System.Linq;
    25 using System.Linq.Expressions;
    2623using HeuristicLab.Common;
    2724using HeuristicLab.Core;
    … …  
    7370    }
    7471
    75     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     72    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    7673      var cov = CovarianceFunctionParameter.Value;
    7774      var selectedDimensions = SelectedDimensionsParameter.Value;
    7875
    79       return cov.GetParameterizedCovarianceFunction(p, selectedDimensions.Intersect(columnIndices));
     76      return cov.GetParameterizedCovarianceFunction(p, selectedDimensions.Intersect(columnIndices).ToArray());
    8077    }
    8178  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceMaternIso.cs

    r12009 r13981  
    111111    }
    112112
    113     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     113    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    114114      double inverseLength, scale;
    115115      int d = DParameter.Value.Value;
    … …  
    122122        double dist = i == j
    123123                       ? 0.0
    124                        : Math.Sqrt(Util.SqrDist(x, i, j, Math.Sqrt(d) * inverseLength, columnIndices));
     124                       : Math.Sqrt(Util.SqrDist(x, i, j, columnIndices, Math.Sqrt(d) * inverseLength));
    125125        return scale * m(d, dist);
    126126      };
    127127      cov.CrossCovariance = (x, xt, i, j) => {
    128         double dist = Math.Sqrt(Util.SqrDist(x, i, xt, j, Math.Sqrt(d) * inverseLength, columnIndices));
     128        double dist = Math.Sqrt(Util.SqrDist(x, i, xt, j, columnIndices, Math.Sqrt(d) * inverseLength));
    129129        return scale * m(d, dist);
    130130      };
    … …  
    155155    }
    156156
    157 
    158     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, int d, double scale, double inverseLength, IEnumerable<int> columnIndices,
     157    private static IList<double> GetGradient(double[,] x, int i, int j, int d, double scale, double inverseLength, int[] columnIndices,
    159158      bool fixedInverseLength, bool fixedScale) {
    160159      double dist = i == j
    161160                   ? 0.0
    162                    : Math.Sqrt(Util.SqrDist(x, i, j, Math.Sqrt(d) * inverseLength, columnIndices));
     161                   : Math.Sqrt(Util.SqrDist(x, i, j, columnIndices, Math.Sqrt(d) * inverseLength));
    163162
    164       if (!fixedInverseLength) yield return scale * dm(d, dist);
    165       if (!fixedScale) yield return 2 * scale * m(d, dist);
     163      var g = new List<double>(2);
     164      if (!fixedInverseLength) g.Add(scale * dm(d, dist));
     165      if (!fixedScale) g.Add(2 * scale * m(d, dist));
     166      return g;
    166167    }
    167168  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceNeuralNetwork.cs

    r12009 r13981  
    102102    }
    103103
    104     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     104    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    105105      double length, scale;
    106106      GetParameterValues(p, out scale, out length);
    … …  
    113113        double s1 = 1.0;
    114114        double s2 = 1.0;
    115         foreach (var col in columnIndices) {
     115        for (int c = 0; c < columnIndices.Length; c++) {
     116          var col = columnIndices[c];
    116117          sx += x[i, col] * x[j, col];
    117118          s1 += x[i, col] * x[i, col];
    … …  
    125126        double s1 = 1.0;
    126127        double s2 = 1.0;
    127         foreach (var col in columnIndices) {
     128        for (int c = 0; c < columnIndices.Length; c++) {
     129          var col = columnIndices[c];
    128130          sx += x[i, col] * xt[j, col];
    129131          s1 += x[i, col] * x[i, col];
    … …  
    138140
    139141    // order of returned gradients must match the order in GetParameterValues!
    140     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double length, double scale, IEnumerable<int> columnIndices,
     142    private static IList<double> GetGradient(double[,] x, int i, int j, double length, double scale, int[] columnIndices,
    141143      bool fixedLength, bool fixedScale) {
    142       {
    143         double sx = 1.0;
    144         double s1 = 1.0;
    145         double s2 = 1.0;
    146         foreach (var col in columnIndices) {
    147           sx += x[i, col] * x[j, col];
    148           s1 += x[i, col] * x[i, col];
    149           s2 += x[j, col] * x[j, col];
    150         }
    151         var h = (length + s1) * (length + s2);
    152         var f = sx / Math.Sqrt(h);
    153         if (!fixedLength) {
    154           yield return -scale / Math.Sqrt(1.0 - f * f) * ((length * sx * (2.0 * length + s1 + s2)) / Math.Pow(h, 3.0 / 2.0));
    155         }
    156         if (!fixedScale) {
    157           yield return 2.0 * scale * Math.Asin(f);
    158         }
     144      double sx = 1.0;
     145      double s1 = 1.0;
     146      double s2 = 1.0;
     147      for (int c = 0; c < columnIndices.Length; c++) {
     148        var col = columnIndices[c];
     149        sx += x[i, col] * x[j, col];
     150        s1 += x[i, col] * x[i, col];
     151        s2 += x[j, col] * x[j, col];
    159152      }
     153      var h = (length + s1) * (length + s2);
     154      var f = sx / Math.Sqrt(h);
     155
     156      var g = new List<double>(2);
     157      if (!fixedLength) g.Add(-scale / Math.Sqrt(1.0 - f * f) * ((length * sx * (2.0 * length + s1 + s2)) / Math.Pow(h, 3.0 / 2.0)));
     158      if (!fixedScale) g.Add(2.0 * scale * Math.Asin(f));
     159      return g;
    160160    }
    161161  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceNoise.cs

    r12009 r13981  
    2121
    2222using System;
    23 using System.Collections.Generic;
    24 using System.Linq;
    2523using HeuristicLab.Common;
    2624using HeuristicLab.Core;
    … …  
    8482    }
    8583
    86     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     84    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    8785      double scale;
    8886      GetParameterValues(p, out scale);
    … …  
    9189      var cov = new ParameterizedCovarianceFunction();
    9290      cov.Covariance = (x, i, j) => i == j ? scale : 0.0;
    93       cov.CrossCovariance = (x, xt, i, j) => Util.SqrDist(x, i, xt, j, 1.0, columnIndices) < 1e-9 ? scale : 0.0;
     91      cov.CrossCovariance = (x, xt, i, j) => Util.SqrDist(x, i, xt, j, columnIndices, 1.0) < 1e-9 ? scale : 0.0;
    9492      if (fixedScale)
    95         cov.CovarianceGradient = (x, i, j) => Enumerable.Empty<double>();
     93        cov.CovarianceGradient = (x, i, j) => new double[0];
    9694      else
    97         cov.CovarianceGradient = (x, i, j) => Enumerable.Repeat(i == j ? 2.0 * scale : 0.0, 1);
     95        cov.CovarianceGradient = (x, i, j) => new double[1] { i == j ? 2.0 * scale : 0.0 };
    9896      return cov;
    9997    }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePeriodic.cs

    r12009 r13981  
    2222using System;
    2323using System.Collections.Generic;
    24 using System.Linq;
    2524using HeuristicLab.Common;
    2625using HeuristicLab.Core;
    … …  
    117116    }
    118117
    119     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     118    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    120119      double inverseLength, period, scale;
    121120      GetParameterValues(p, out scale, out period, out inverseLength);
    … …  
    145144    }
    146145
    147 
    148     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double period, double inverseLength,
     146    private static IList<double> GetGradient(double[,] x, int i, int j, int[] columnIndices, double scale, double period, double inverseLength,
    149147      bool fixedInverseLength, bool fixedPeriod, bool fixedScale) {
    150148      double k = i == j ? 0.0 : Math.PI * GetDistance(x, x, i, j, columnIndices) / period;
    151149      double gradient = Math.Sin(k) * inverseLength;
    152150      gradient *= gradient;
    153       if (!fixedInverseLength) yield return 4.0 * scale * Math.Exp(-2.0 * gradient) * gradient;
     151      var g = new List<double>(3);
     152      if (!fixedInverseLength)
     153        g.Add(4.0 * scale * Math.Exp(-2.0 * gradient) * gradient);
    154154      if (!fixedPeriod) {
    155155        double r = Math.Sin(k) * inverseLength;
    156         yield return 2.0 * k * scale * Math.Exp(-2 * r * r) * Math.Sin(2 * k) * inverseLength * inverseLength;
     156        g.Add(2.0 * k * scale * Math.Exp(-2 * r * r) * Math.Sin(2 * k) * inverseLength * inverseLength);
    157157      }
    158158      if (!fixedScale)
    159         yield return 2.0 * scale * Math.Exp(-2 * gradient);
    160 
     159        g.Add(2.0 * scale * Math.Exp(-2 * gradient));
     160      return g;
    161161    }
    162162
    163     private static double GetDistance(double[,] x, double[,] xt, int i, int j, IEnumerable<int> columnIndices) {
    164       return Math.Sqrt(Util.SqrDist(x, i, xt, j, 1, columnIndices));
     163    private static double GetDistance(double[,] x, double[,] xt, int i, int j, int[] columnIndices) {
     164      return Math.Sqrt(Util.SqrDist(x, i, xt, j, columnIndices, 1));
    165165    }
    166166  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePiecewisePolynomial.cs

    r12009 r13981  
    6969      Parameters.Add(new OptionalValueParameter<DoubleValue>("Scale", "The scale parameter of the piecewise polynomial covariance function."));
    7070
    71       var validValues = new ItemSet<IntValue>(new IntValue[] { 
    72         (IntValue)(new IntValue().AsReadOnly()), 
    73         (IntValue)(new IntValue(1).AsReadOnly()), 
    74         (IntValue)(new IntValue(2).AsReadOnly()), 
     71      var validValues = new ItemSet<IntValue>(new IntValue[] {
     72        (IntValue)(new IntValue().AsReadOnly()),
     73        (IntValue)(new IntValue(1).AsReadOnly()),
     74        (IntValue)(new IntValue(2).AsReadOnly()),
    7575        (IntValue)(new IntValue(3).AsReadOnly()) });
    7676      Parameters.Add(new ConstrainedValueParameter<IntValue>("V", "The v parameter of the piecewise polynomial function (allowed values 0, 1, 2, 3).", validValues, validValues.First()));
    … …  
    113113    }
    114114
    115     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     115    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    116116      double length, scale;
    117117      int v = VParameter.Value.Value;
    … …  
    148148      var cov = new ParameterizedCovarianceFunction();
    149149      cov.Covariance = (x, i, j) => {
    150         double k = Math.Sqrt(Util.SqrDist(x, i, x, j, 1.0 / length, columnIndices));
     150        double k = Math.Sqrt(Util.SqrDist(x, i, x, j, columnIndices, 1.0 / length));
    151151        return scale * Math.Pow(Math.Max(1 - k, 0), exp + v) * f(k);
    152152      };
    153153      cov.CrossCovariance = (x, xt, i, j) => {
    154         double k = Math.Sqrt(Util.SqrDist(x, i, xt, j, 1.0 / length, columnIndices));
     154        double k = Math.Sqrt(Util.SqrDist(x, i, xt, j, columnIndices, 1.0 / length));
    155155        return scale * Math.Pow(Math.Max(1 - k, 0), exp + v) * f(k);
    156156      };
    … …  
    159159    }
    160160
    161     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double length, double scale, int v, double exp, Func<double, double> f, Func<double, double> df, IEnumerable<int> columnIndices,
     161    private static IList<double> GetGradient(double[,] x, int i, int j, double length, double scale, int v, double exp, Func<double, double> f, Func<double, double> df, int[] columnIndices,
    162162      bool fixedLength, bool fixedScale) {
    163       double k = Math.Sqrt(Util.SqrDist(x, i, x, j, 1.0 / length, columnIndices));
    164       if (!fixedLength) yield return scale * Math.Pow(Math.Max(1.0 - k, 0), exp + v - 1) * k * ((exp + v) * f(k) - Math.Max(1 - k, 0) * df(k));
    165       if (!fixedScale) yield return 2.0 * scale * Math.Pow(Math.Max(1 - k, 0), exp + v) * f(k);
     163      double k = Math.Sqrt(Util.SqrDist(x, i, x, j, columnIndices, 1.0 / length));
     164      var g = new List<double>(2);
     165      if (!fixedLength) g.Add(scale * Math.Pow(Math.Max(1.0 - k, 0), exp + v - 1) * k * ((exp + v) * f(k) - Math.Max(1 - k, 0) * df(k)));
     166      if (!fixedScale) g.Add(2.0 * scale * Math.Pow(Math.Max(1 - k, 0), exp + v) * f(k));
     167      return g;
    166168    }
    167169  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePolynomial.cs

    r12009 r13981  
    2222using System;
    2323using System.Collections.Generic;
    24 using System.Linq;
    2524using HeuristicLab.Common;
    2625using HeuristicLab.Core;
    … …  
    107106    }
    108107
    109     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     108    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    110109      double @const, scale;
    111110      int degree = DegreeParameter.Value.Value;
    … …  
    116115      // create functions
    117116      var cov = new ParameterizedCovarianceFunction();
    118       cov.Covariance = (x, i, j) => scale * Math.Pow(@const + Util.ScalarProd(x, i, j, 1.0, columnIndices), degree);
    119       cov.CrossCovariance = (x, xt, i, j) => scale * Math.Pow(@const + Util.ScalarProd(x, i, xt, j, 1.0, columnIndices), degree);
     117      cov.Covariance = (x, i, j) => scale * Math.Pow(@const + Util.ScalarProd(x, i, j, columnIndices, 1.0), degree);
     118      cov.CrossCovariance = (x, xt, i, j) => scale * Math.Pow(@const + Util.ScalarProd(x, i, xt, j, columnIndices, 1.0), degree);
    120119      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, @const, scale, degree, columnIndices, fixedConst, fixedScale);
    121120      return cov;
    122121    }
    123122
    124     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double c, double scale, int degree, IEnumerable<int> columnIndices,
     123    private static IList<double> GetGradient(double[,] x, int i, int j, double c, double scale, int degree, int[] columnIndices,
    125124      bool fixedConst, bool fixedScale) {
    126       double s = Util.ScalarProd(x, i, j, 1.0, columnIndices);
    127       if (!fixedConst) yield return c * degree * scale * Math.Pow(c + s, degree - 1);
    128       if (!fixedScale) yield return 2 * scale * Math.Pow(c + s, degree);
     125      double s = Util.ScalarProd(x, i, j, columnIndices, 1.0);
     126      var g = new List<double>(2);
     127      if (!fixedConst) g.Add(c * degree * scale * Math.Pow(c + s, degree - 1));
     128      if (!fixedScale) g.Add(2 * scale * Math.Pow(c + s, degree));
     129      return g;
    129130    }
    130131  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceProduct.cs

    r12009 r13981  
    2323using System.Collections.Generic;
    2424using System.Linq;
    25 using System.Linq.Expressions;
    2625using HeuristicLab.Common;
    2726using HeuristicLab.Core;
    … …  
    7675    }
    7776
    78     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     77    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    7978      if (factors.Count == 0) throw new ArgumentException("at least one factor is necessary for the product covariance function.");
    8079      var functions = new List<ParameterizedCovarianceFunction>();
    … …  
    9392    }
    9493
    95     public static IEnumerable<double> GetGradient(double[,] x, int i, int j, List<ParameterizedCovarianceFunction> factorFunctions) {
     94    public static IList<double> GetGradient(double[,] x, int i, int j, List<ParameterizedCovarianceFunction> factorFunctions) {
    9695      var covariances = factorFunctions.Select(f => f.Covariance(x, i, j)).ToArray();
     96      var gr = new List<double>();
    9797      for (int ii = 0; ii < factorFunctions.Count; ii++) {
    9898        foreach (var g in factorFunctions[ii].CovarianceGradient(x, i, j)) {
    … …  
    100100          for (int jj = 0; jj < covariances.Length; jj++)
    101101            if (ii != jj) res *= covariances[jj];
    102           yield return res;
     102          gr.Add(res);
    103103        }
    104104      }
     105      return gr;
    105106    }
    106107  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceRationalQuadraticArd.cs

    r12009 r13981  
    121121    }
    122122
    123     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     123    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    124124      double scale, shape;
    125125      double[] inverseLength;
    … …  
    144144    }
    145145
    146     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double shape, double[] inverseLength,
     146    private static IList<double> GetGradient(double[,] x, int i, int j, int[] columnIndices, double scale, double shape, double[] inverseLength,
    147147      bool fixedInverseLength, bool fixedScale, bool fixedShape) {
    148148      double d = i == j
    … …  
    151151      double b = 1 + 0.5 * d / shape;
    152152      int k = 0;
     153      var g = new List<double>(columnIndices.Length + 2);
    153154      if (!fixedInverseLength) {
    154155        foreach (var columnIndex in columnIndices) {
    155           yield return
     156          g.Add(
    156157            scale * Math.Pow(b, -shape - 1) *
    157             Util.SqrDist(x[i, columnIndex] * inverseLength[k], x[j, columnIndex] * inverseLength[k]);
     158            Util.SqrDist(x[i, columnIndex] * inverseLength[k], x[j, columnIndex] * inverseLength[k]));
    158159          k++;
    159160        }
    160161      }
    161       if (!fixedScale) yield return 2 * scale * Math.Pow(b, -shape);
    162       if (!fixedShape) yield return scale * Math.Pow(b, -shape) * (0.5 * d / b - shape * Math.Log(b));
     162      if (!fixedScale) g.Add(2 * scale * Math.Pow(b, -shape));
     163      if (!fixedShape) g.Add(scale * Math.Pow(b, -shape) * (0.5 * d / b - shape * Math.Log(b)));
     164      return g;
    163165    }
    164166  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceRationalQuadraticIso.cs

    r12009 r13981  
    117117    }
    118118
    119     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     119    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    120120      double scale, shape, inverseLength;
    121121      GetParameterValues(p, out scale, out shape, out inverseLength);
    … …  
    128128        double d = i == j
    129129                    ? 0.0
    130                     : Util.SqrDist(x, i, j, inverseLength, columnIndices);
     130                    : Util.SqrDist(x, i, j, columnIndices, inverseLength);
    131131        return scale * Math.Pow(1 + 0.5 * d / shape, -shape);
    132132      };
    133133      cov.CrossCovariance = (x, xt, i, j) => {
    134         double d = Util.SqrDist(x, i, xt, j, inverseLength, columnIndices);
     134        double d = Util.SqrDist(x, i, xt, j, columnIndices, inverseLength);
    135135        return scale * Math.Pow(1 + 0.5 * d / shape, -shape);
    136136      };
    … …  
    139139    }
    140140
    141     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double shape, double inverseLength,
     141    private static IList<double> GetGradient(double[,] x, int i, int j, int[] columnIndices, double scale, double shape, double inverseLength,
    142142      bool fixedInverseLength, bool fixedScale, bool fixedShape) {
    143143      double d = i == j
    144144                   ? 0.0
    145                    : Util.SqrDist(x, i, j, inverseLength, columnIndices);
     145                   : Util.SqrDist(x, i, j, columnIndices, inverseLength);
    146146
    147147      double b = 1 + 0.5 * d / shape;
    148       if (!fixedInverseLength) yield return scale * Math.Pow(b, -shape - 1) * d;
    149       if (!fixedScale) yield return 2 * scale * Math.Pow(b, -shape);
    150       if (!fixedShape) yield return scale * Math.Pow(b, -shape) * (0.5 * d / b - shape * Math.Log(b));
     148      var g = new List<double>(3);
     149      if (!fixedInverseLength) g.Add(scale * Math.Pow(b, -shape - 1) * d);
     150      if (!fixedScale) g.Add(2 * scale * Math.Pow(b, -shape));
     151      if (!fixedShape) g.Add(scale * Math.Pow(b, -shape) * (0.5 * d / b - shape * Math.Log(b)));
     152      return g;
    151153    }
    152154  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceScale.cs

    r12009 r13981  
    8787    }
    8888
    89     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     89    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    9090      double scale;
    9191      GetParameterValues(p, out scale);
    … …  
    100100    }
    101101
    102     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, ParameterizedCovarianceFunction cov,
     102    private static IList<double> GetGradient(double[,] x, int i, int j, int[] columnIndices, double scale, ParameterizedCovarianceFunction cov,
    103103      bool fixedScale) {
     104      var gr = new List<double>((!fixedScale ? 1 : 0) + cov.CovarianceGradient(x, i, j).Count);
    104105      if (!fixedScale) {
    105         yield return 2 * scale * cov.Covariance(x, i, j);
     106        gr.Add(2 * scale * cov.Covariance(x, i, j));
    106107      }
    107108      foreach (var g in cov.CovarianceGradient(x, i, j))
    108         yield return scale * g;
     109        gr.Add(scale * g);
     110      return gr;
    109111    }
    110112  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSpectralMixture.cs

    r12009 r13981  
    2323using System.Collections.Generic;
    2424using System.Linq;
    25 using System.Linq.Expressions;
    2625using HeuristicLab.Common;
    2726using HeuristicLab.Core;
    … …  
    131130    }
    132131
    133     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     132    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    134133      double[] weight, frequency, lengthScale;
    135134      GetParameterValues(p, out weight, out frequency, out lengthScale);
    … …  
    152151    }
    153152
    154     private static double GetCovariance(double[,] x, double[,] xt, int i, int j, int maxQ, double[] weight, double[] frequency, double[] lengthScale, IEnumerable<int> columnIndices) {
     153    private static double GetCovariance(double[,] x, double[,] xt, int i, int j, int maxQ, double[] weight, double[] frequency, double[] lengthScale, int[] columnIndices) {
    155154      // tau = x - x' (only for selected variables)
    156155      double[] tau =
    … …  
    164163        int idx = 0; // helper index for tau
    165164        // for each selected variable
    166         foreach (var c in columnIndices) {
    167           kc *= f1(tau[idx], lengthScale[q * numberOfVariables + c]) * f2(tau[idx], frequency[q * numberOfVariables + c]);
     165        for (int c = 0; c < columnIndices.Length; c++) {
     166          var col = columnIndices[c];
     167          kc *= f1(tau[idx], lengthScale[q * numberOfVariables + col]) * f2(tau[idx], frequency[q * numberOfVariables + col]);
    168168          idx++;
    169169        }
    … …  
    181181
    182182    // order of returned gradients must match the order in GetParameterValues!
    183     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, int maxQ, double[] weight, double[] frequency, double[] lengthScale, IEnumerable<int> columnIndices,
     183    private static IList<double> GetGradient(double[,] x, int i, int j, int maxQ, double[] weight, double[] frequency, double[] lengthScale, int[] columnIndices,
    184184      bool fixedWeight, bool fixedFrequency, bool fixedLengthScale) {
    185185      double[] tau = Util.GetRow(x, i, columnIndices).Zip(Util.GetRow(x, j, columnIndices), (xi, xj) => xi - xj).ToArray();
    186186      int numberOfVariables = lengthScale.Length / maxQ;
    187187
     188      var g = new List<double>((!fixedWeight ? maxQ : 0) + (!fixedFrequency ? maxQ * columnIndices.Length : 0) + (!fixedLengthScale ? maxQ * columnIndices.Length : 0));
    188189      if (!fixedWeight) {
    189190        // weight
    … …  
    193194          int idx = 0; // helper index for tau
    194195          // for each selected variable
    195           foreach (var c in columnIndices) {
    196             k *= f1(tau[idx], lengthScale[q * numberOfVariables + c]) * f2(tau[idx], frequency[q * numberOfVariables + c]);
     196          for (int c = 0; c < columnIndices.Length; c++) {
     197            var col = columnIndices[c];
     198            k *= f1(tau[idx], lengthScale[q * numberOfVariables + col]) * f2(tau[idx], frequency[q * numberOfVariables + col]);
    197199            idx++;
    198200          }
    199           yield return k;
     201          g.Add(k);
    200202        }
    201203      }
    … …  
    212214                       Math.Sin(2 * Math.PI * tau[idx] * frequency[q * numberOfVariables + c]);
    213215            idx++;
    214             yield return weight[q] * k;
     216            g.Add(weight[q] * k);
    215217          }
    216218        }
    … …  
    228230                       f2(tau[idx], frequency[q * numberOfVariables + c]);
    229231            idx++;
    230             yield return weight[q] * k;
     232            g.Add(weight[q] * k);
    231233          }
    232234        }
    233235      }
     236
     237      return g;
    234238    }
    235239  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSquaredExponentialArd.cs

    r12009 r13981  
    9999    }
    100100
    101     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     101    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    102102      double scale;
    103103      double[] inverseLength;
    … …  
    122122
    123123    // order of returned gradients must match the order in GetParameterValues!
    124     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double[] inverseLength,
     124    private static IList<double> GetGradient(double[,] x, int i, int j, int[] columnIndices, double scale, double[] inverseLength,
    125125      bool fixedInverseLength, bool fixedScale) {
    126126      double d = i == j
    … …  
    129129
    130130      int k = 0;
     131      var g = new List<double>((!fixedInverseLength ? columnIndices.Length : 0) + (!fixedScale ? 1 : 0));
    131132      if (!fixedInverseLength) {
    132         foreach (var columnIndex in columnIndices) {
     133        for (int c = 0; c < columnIndices.Length; c++) {
     134          var columnIndex = columnIndices[c];
    133135          double sqrDist = Util.SqrDist(x[i, columnIndex] * inverseLength[k], x[j, columnIndex] * inverseLength[k]);
    134           yield return scale * Math.Exp(-d / 2.0) * sqrDist;
     136          g.Add(scale * Math.Exp(-d / 2.0) * sqrDist);
    135137          k++;
    136138        }
    137139      }
    138       if (!fixedScale) yield return 2.0 * scale * Math.Exp(-d / 2.0);
     140      if (!fixedScale) g.Add(2.0 * scale * Math.Exp(-d / 2.0));
     141      return g;
    139142    }
    140143  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSquaredExponentialIso.cs

    r12009 r13981  
    2222using System;
    2323using System.Collections.Generic;
    24 using System.Linq.Expressions;
    2524using HeuristicLab.Common;
    2625using HeuristicLab.Core;
    … …  
    104103    }
    105104
    106     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     105    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    107106      double inverseLength, scale;
    108107      GetParameterValues(p, out scale, out inverseLength);
    … …  
    114113        double d = i == j
    115114                ? 0.0
    116                 : Util.SqrDist(x, i, j, inverseLength, columnIndices);
     115                : Util.SqrDist(x, i, j, columnIndices, inverseLength);
    117116        return scale * Math.Exp(-d / 2.0);
    118117      };
    119118      cov.CrossCovariance = (x, xt, i, j) => {
    120         double d = Util.SqrDist(x, i, xt, j, inverseLength, columnIndices);
     119        double d = Util.SqrDist(x, i, xt, j, columnIndices, inverseLength);
    121120        return scale * Math.Exp(-d / 2.0);
    122121      };
    … …  
    127126
    128127    // order of returned gradients must match the order in GetParameterValues!
    129     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double sf2, double inverseLength, IEnumerable<int> columnIndices,
     128    private static IList<double> GetGradient(double[,] x, int i, int j, double sf2, double inverseLength, int[] columnIndices,
    130129      bool fixedInverseLength, bool fixedScale) {
    131130      double d = i == j
    132131                   ? 0.0
    133                    : Util.SqrDist(x, i, j, inverseLength, columnIndices);
     132                   : Util.SqrDist(x, i, j, columnIndices, inverseLength);
    134133      double g = Math.Exp(-d / 2.0);
    135       if (!fixedInverseLength) yield return sf2 * g * d;
    136       if (!fixedScale) yield return 2.0 * sf2 * g;
     134      var gr = new List<double>(2);
     135      if (!fixedInverseLength) gr.Add(sf2 * g * d);
     136      if (!fixedScale) gr.Add(2.0 * sf2 * g);
     137      return gr;
    137138    }
    138139  }

  • stable/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSum.cs

    r12009 r13981  
    2323using System.Collections.Generic;
    2424using System.Linq;
    25 using System.Linq.Expressions;
    2625using HeuristicLab.Common;
    2726using HeuristicLab.Core;
    … …  
    7675    }
    7776
    78     public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
     77    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, int[] columnIndices) {
    7978      if (terms.Count == 0) throw new ArgumentException("at least one term is necessary for the product covariance function.");
    8079      var functions = new List<ParameterizedCovarianceFunction>();
    … …  
    8887      sum.Covariance = (x, i, j) => functions.Select(e => e.Covariance(x, i, j)).Sum();
    8988      sum.CrossCovariance = (x, xt, i, j) => functions.Select(e => e.CrossCovariance(x, xt, i, j)).Sum();
    90       sum.CovarianceGradient = (x, i, j) => functions.Select(e => e.CovarianceGradient(x, i, j)).Aggregate(Enumerable.Concat);
     89      sum.CovarianceGradient = (x, i, j) => {
     90        var g = new List<double>();
     91        foreach (var e in functions)
     92          g.AddRange(e.CovarianceGradient(x, i, j));
     93        return g;
     94      };
    9195      return sum;
    9296    }
Note: See TracChangeset for help on using the changeset viewer.