Changeset 10489


Ignore:
Timestamp:
02/20/14 17:45:06 (5 years ago)
Author:
gkronber
Message:

#2125 fixed the bug that covariance functions returned the full gradient vector even when parameters are partially fixed.
changed the calculation of NN covariance and gradient to direct calculation (instead of AutoDiff)

Location:
trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceConst.cs

    r9456 r10489  
    2222using System;
    2323using System.Collections.Generic;
     24using System.Linq;
    2425using HeuristicLab.Common;
    2526using HeuristicLab.Core;
     
    3637      get { return (IValueParameter<DoubleValue>)Parameters["Scale"]; }
    3738    }
    38 
     39    private bool HasFixedScaleParameter {
     40      get { return ScaleParameter.Value != null; }
     41    }
    3942    [StorableConstructor]
    4043    private CovarianceConst(bool deserializing)
     
    5962
    6063    public int GetNumberOfParameters(int numberOfVariables) {
    61       return ScaleParameter.Value != null ? 0 : 1;
     64      return HasFixedScaleParameter ? 0 : 1;
    6265    }
    6366
     
    7174      int c = 0;
    7275      // gather parameter values
    73       if (ScaleParameter.Value != null) {
     76      if (HasFixedScaleParameter) {
    7477        scale = ScaleParameter.Value.Value;
    7578      } else {
     
    8790      cov.Covariance = (x, i, j) => scale;
    8891      cov.CrossCovariance = (x, xt, i, j) => scale;
    89       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, scale, columnIndices);
     92      if (HasFixedScaleParameter) {
     93        cov.CovarianceGradient = (x, i, j) => Enumerable.Empty<double>();
     94      } else {
     95        cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, scale, columnIndices);
     96      }
    9097      return cov;
    9198    }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinearArd.cs

    r9456 r10489  
    3737      get { return (IValueParameter<DoubleArray>)Parameters["InverseLength"]; }
    3838    }
     39    private bool HasFixedInverseLengthParameter {
     40      get { return InverseLengthParameter.Value != null; }
     41    }
    3942
    4043    [StorableConstructor]
     
    5760
    5861    public int GetNumberOfParameters(int numberOfVariables) {
    59       if (InverseLengthParameter.Value == null)
     62      if (HasFixedInverseLengthParameter)
     63        return 0;
     64      else
    6065        return numberOfVariables;
    61       else
    62         return 0;
    6366    }
    6467
     
    7174    private void GetParameterValues(double[] p, out double[] inverseLength) {
    7275      // gather parameter values
    73       if (InverseLengthParameter.Value != null) {
     76      if (HasFixedInverseLengthParameter) {
    7477        inverseLength = InverseLengthParameter.Value.ToArray();
    7578      } else {
     
    8184      double[] inverseLength;
    8285      GetParameterValues(p, out inverseLength);
     86      var fixedInverseLength = HasFixedInverseLengthParameter;
    8387      // create functions
    8488      var cov = new ParameterizedCovarianceFunction();
    8589      cov.Covariance = (x, i, j) => Util.ScalarProd(x, i, j, inverseLength, columnIndices);
    8690      cov.CrossCovariance = (x, xt, i, j) => Util.ScalarProd(x, i, xt, j, inverseLength, columnIndices);
    87       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, inverseLength, columnIndices);
     91      if (fixedInverseLength)
     92        cov.CovarianceGradient = (x, i, j) => Enumerable.Empty<double>();
     93      else
     94        cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, inverseLength, columnIndices);
    8895      return cov;
    8996    }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceMaternIso.cs

    r9456 r10489  
    4545      get { return (IConstrainedValueParameter<IntValue>)Parameters["D"]; }
    4646    }
    47 
     47    private bool HasFixedScaleParameter {
     48      get { return ScaleParameter.Value != null; }
     49    }
     50    private bool HasFixedInverseLengthParameter {
     51      get { return InverseLengthParameter.Value != null; }
     52    }
    4853
    4954    [StorableConstructor]
     
    7681    public int GetNumberOfParameters(int numberOfVariables) {
    7782      return
    78         (InverseLengthParameter.Value != null ? 0 : 1) +
    79         (ScaleParameter.Value != null ? 0 : 1);
     83        (HasFixedInverseLengthParameter ? 0 : 1) +
     84        (HasFixedScaleParameter ? 0 : 1);
    8085    }
    8186
     
    9095      // gather parameter values
    9196      int c = 0;
    92       if (InverseLengthParameter.Value != null) {
     97      if (HasFixedInverseLengthParameter) {
    9398        inverseLength = InverseLengthParameter.Value.Value;
    9499      } else {
     
    97102      }
    98103
    99       if (ScaleParameter.Value != null) {
     104      if (HasFixedScaleParameter) {
    100105        scale = ScaleParameter.Value.Value;
    101106      } else {
     
    110115      int d = DParameter.Value.Value;
    111116      GetParameterValues(p, out scale, out inverseLength);
     117      var fixedInverseLength = HasFixedInverseLengthParameter;
     118      var fixedScale = HasFixedScaleParameter;
    112119      // create functions
    113120      var cov = new ParameterizedCovarianceFunction();
     
    122129        return scale * m(d, dist);
    123130      };
    124       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, d, scale, inverseLength, columnIndices);
     131      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, d, scale, inverseLength, columnIndices, fixedInverseLength, fixedScale);
    125132      return cov;
    126133    }
     
    149156
    150157
    151     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, int d, double scale, double inverseLength, IEnumerable<int> columnIndices) {
     158    private static IEnumerable<double> GetGradient(double[,] x, int i, int j, int d, double scale, double inverseLength, IEnumerable<int> columnIndices,
     159      bool fixedInverseLength, bool fixedScale) {
    152160      double dist = i == j
    153161                   ? 0.0
    154162                   : Math.Sqrt(Util.SqrDist(x, i, j, Math.Sqrt(d) * inverseLength, columnIndices));
    155163
    156       yield return scale * dm(d, dist);
    157       yield return 2 * scale * m(d, dist);
     164      if (!fixedInverseLength) yield return scale * dm(d, dist);
     165      if (!fixedScale) yield return 2 * scale * m(d, dist);
    158166    }
    159167  }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceNeuralNetwork.cs

    r9542 r10489  
    4343      get { return (IValueParameter<DoubleValue>)Parameters["Length"]; }
    4444    }
     45    private bool HasFixedScaleParameter {
     46      get { return ScaleParameter.Value != null; }
     47    }
     48    private bool HasFixedLengthParameter {
     49      get { return LengthParameter.Value != null; }
     50    }
    4551
    4652    [StorableConstructor]
     
    6874    public int GetNumberOfParameters(int numberOfVariables) {
    6975      return
    70         (ScaleParameter.Value != null ? 0 : 1) +
    71         (LengthParameter.Value != null ? 0 : 1);
     76        (HasFixedScaleParameter ? 0 : 1) +
     77        (HasFixedLengthParameter ? 0 : 1);
    7278    }
    7379
     
    8389      // gather parameter values
    8490      int c = 0;
    85       if (LengthParameter.Value != null) {
     91      if (HasFixedLengthParameter) {
    8692        length = LengthParameter.Value.Value;
    8793      } else {
     
    9096      }
    9197
    92       if (ScaleParameter.Value != null) {
     98      if (HasFixedScaleParameter) {
    9399        scale = ScaleParameter.Value.Value;
    94100      } else {
     
    110116      double length, scale;
    111117      GetParameterValues(p, out scale, out length);
    112       // create functions
    113       AutoDiff.Variable p0 = new AutoDiff.Variable();
    114       AutoDiff.Variable p1 = new AutoDiff.Variable();
    115       var l = TermBuilder.Exp(2.0 * p0);
    116       var s = TermBuilder.Exp(2.0 * p1);
    117       AutoDiff.Variable[] x1 = new AutoDiff.Variable[columnIndices.Count()];
    118       AutoDiff.Variable[] x2 = new AutoDiff.Variable[columnIndices.Count()];
    119       AutoDiff.Term sx = 1;
    120       AutoDiff.Term s1 = 1;
    121       AutoDiff.Term s2 = 1;
    122       for (int k = 0; k < columnIndices.Count(); k++) {
    123         x1[k] = new AutoDiff.Variable();
    124         x2[k] = new AutoDiff.Variable();
    125         sx += x1[k] * x2[k];
    126         s1 += x1[k] * x1[k];
    127         s2 += x2[k] * x2[k];
    128       }
    129 
    130       var parameter = x1.Concat(x2).Concat(new AutoDiff.Variable[] { p0, p1 }).ToArray();
    131       var values = new double[x1.Length + x2.Length + 2];
    132       var c = (s * asin(sx / (sqrt((l + s1) * (l + s2))))).Compile(parameter);
     118      var fixedLength = HasFixedLengthParameter;
     119      var fixedScale = HasFixedScaleParameter;
    133120
    134121      var cov = new ParameterizedCovarianceFunction();
    135122      cov.Covariance = (x, i, j) => {
    136         int k = 0;
     123        double sx = 1.0;
     124        double s1 = 1.0;
     125        double s2 = 1.0;
    137126        foreach (var col in columnIndices) {
    138           values[k] = x[i, col];
    139           k++;
     127          sx += x[i, col] * x[j, col];
     128          s1 += x[i, col] * x[i, col];
     129          s2 += x[j, col] * x[j, col];
    140130        }
    141         foreach (var col in columnIndices) {
    142           values[k] = x[j, col];
    143           k++;
    144         }
    145         values[k] = Math.Log(Math.Sqrt(length));
    146         values[k + 1] = Math.Log(Math.Sqrt(scale));
    147         return c.Evaluate(values);
     131
     132        return (scale * Math.Asin(sx / (Math.Sqrt((length + s1) * (length + s2)))));
    148133      };
    149134      cov.CrossCovariance = (x, xt, i, j) => {
    150         int k = 0;
     135        double sx = 1.0;
     136        double s1 = 1.0;
     137        double s2 = 1.0;
    151138        foreach (var col in columnIndices) {
    152           values[k] = x[i, col];
    153           k++;
     139          sx += x[i, col] * xt[j, col];
     140          s1 += x[i, col] * x[i, col];
     141          s2 += xt[j, col] * xt[j, col];
    154142        }
     143
     144        return (scale * Math.Asin(sx / (Math.Sqrt((length + s1) * (length + s2)))));
     145      };
     146      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, length, scale, columnIndices, fixedLength, fixedScale);
     147      return cov;
     148    }
     149
     150    // order of returned gradients must match the order in GetParameterValues!
     151    private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double length, double scale, IEnumerable<int> columnIndices,
     152      bool fixedLength, bool fixedScale) {
     153      {
     154        double sx = 1.0;
     155        double s1 = 1.0;
     156        double s2 = 1.0;
    155157        foreach (var col in columnIndices) {
    156           values[k] = xt[j, col];
    157           k++;
     158          sx += x[i, col] * x[j, col];
     159          s1 += x[i, col] * x[i, col];
     160          s2 += x[j, col] * x[j, col];
    158161        }
    159         values[k] = Math.Log(Math.Sqrt(length));
    160         values[k + 1] = Math.Log(Math.Sqrt(scale));
    161         return c.Evaluate(values);
     162        var h = (length + s1) * (length + s2);
     163        var f = sx / Math.Sqrt(h);
     164        if (!fixedLength) {
     165          yield return -scale / Math.Sqrt(1.0 - f * f) * ((length * sx * (2.0 * length + s1 + s2)) / Math.Pow(h, 3.0 / 2.0));
     166        }
     167        if (!fixedScale) {
     168          yield return 2.0 * scale * Math.Asin(f);
     169        }
     170
    162171      };
    163       cov.CovarianceGradient = (x, i, j) => {
    164         int k = 0;
    165         foreach (var col in columnIndices) {
    166           values[k] = x[i, col];
    167           k++;
    168         }
    169         foreach (var col in columnIndices) {
    170           values[k] = x[j, col];
    171           k++;
    172         }
    173         values[k] = Math.Log(Math.Sqrt(length));
    174         values[k + 1] = Math.Log(Math.Sqrt(scale));
    175         return c.Differentiate(values).Item1.Skip(columnIndices.Count() * 2);
    176       };
    177       return cov;
    178172    }
    179173
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceNoise.cs

    r9544 r10489  
    3737      get { return (IValueParameter<DoubleValue>)Parameters["Scale"]; }
    3838    }
     39    private bool HasFixedScaleParameter {
     40      get { return ScaleParameter.Value != null; }
     41    }
    3942
    4043    [StorableConstructor]
     
    6063
    6164    public int GetNumberOfParameters(int numberOfVariables) {
    62       return ScaleParameter.Value != null ? 0 : 1;
     65      return HasFixedScaleParameter ? 0 : 1;
    6366    }
    6467
     
    7275      int c = 0;
    7376      // gather parameter values
    74       if (ScaleParameter.Value != null) {
     77      if (HasFixedScaleParameter) {
    7578        scale = ScaleParameter.Value.Value;
    7679      } else {
     
    8487      double scale;
    8588      GetParameterValues(p, out scale);
     89      var fixedScale = HasFixedScaleParameter;
    8690      // create functions
    8791      var cov = new ParameterizedCovarianceFunction();
    8892      cov.Covariance = (x, i, j) => i == j ? scale : 0.0;
    8993      cov.CrossCovariance = (x, xt, i, j) => Util.SqrDist(x, i, xt, j, 1.0, columnIndices) < 1e-9 ? scale : 0.0;
    90       cov.CovarianceGradient = (x, i, j) => Enumerable.Repeat(i == j ? 2.0 * scale : 0.0, 1);
     94      if (fixedScale)
     95        cov.CovarianceGradient = (x, i, j) => Enumerable.Empty<double>();
     96      else
     97        cov.CovarianceGradient = (x, i, j) => Enumerable.Repeat(i == j ? 2.0 * scale : 0.0, 1);
    9198      return cov;
    9299    }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePeriodic.cs

    r9456 r10489  
    4646    }
    4747
     48    private bool HasFixedScaleParameter {
     49      get { return ScaleParameter.Value != null; }
     50    }
     51    private bool HasFixedInverseLengthParameter {
     52      get { return InverseLengthParameter.Value != null; }
     53    }
     54    private bool HasFixedPeriodParameter {
     55      get { return PeriodParameter.Value != null; }
     56    }
     57
    4858
    4959    [StorableConstructor]
     
    6878
    6979    public int GetNumberOfParameters(int numberOfVariables) {
    70       return (ScaleParameter.Value != null ? 0 : 1) +
    71        (PeriodParameter.Value != null ? 0 : 1) +
    72        (InverseLengthParameter.Value != null ? 0 : 1);
     80      return (HasFixedScaleParameter ? 0 : 1) +
     81       (HasFixedPeriodParameter ? 0 : 1) +
     82       (HasFixedInverseLengthParameter ? 0 : 1);
    7383    }
    7484
     
    8292
    8393
    84     private void GetParameterValues(double[] 
     94    private void GetParameterValues(double[]
    8595      p, out double scale, out double period, out double inverseLength) {
    8696      // gather parameter values
    8797      int c = 0;
    88       if (InverseLengthParameter.Value != null) {
     98      if (HasFixedInverseLengthParameter) {
    8999        inverseLength = InverseLengthParameter.Value.Value;
    90100      } else {
     
    92102        c++;
    93103      }
    94       if (PeriodParameter.Value != null) {
     104      if (HasFixedPeriodParameter) {
    95105        period = PeriodParameter.Value.Value;
    96106      } else {
     
    98108        c++;
    99109      }
    100       if (ScaleParameter.Value != null) {
     110      if (HasFixedScaleParameter) {
    101111        scale = ScaleParameter.Value.Value;
    102112      } else {
     
    110120      double inverseLength, period, scale;
    111121      GetParameterValues(p, out scale, out period, out inverseLength);
     122      var fixedInverseLength = HasFixedInverseLengthParameter;
     123      var fixedPeriod = HasFixedPeriodParameter;
     124      var fixedScale = HasFixedScaleParameter;
    112125      // create functions
    113126      var cov = new ParameterizedCovarianceFunction();
     
    128141        return scale * Math.Exp(-2.0 * k);
    129142      };
    130       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, columnIndices, scale, period, inverseLength);
     143      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, columnIndices, scale, period, inverseLength, fixedInverseLength, fixedPeriod, fixedScale);
    131144      return cov;
    132145    }
    133146
    134147
    135     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double period, double inverseLength) {
     148    private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double period, double inverseLength,
     149      bool fixedInverseLength, bool fixedPeriod, bool fixedScale) {
    136150      double k = i == j ? 0.0 : Math.PI * GetDistance(x, x, i, j, columnIndices) / period;
    137151      double gradient = Math.Sin(k) * inverseLength;
    138152      gradient *= gradient;
    139       yield return 4.0 * scale * Math.Exp(-2.0 * gradient) * gradient;
    140       double r = Math.Sin(k) * inverseLength;
    141       yield return 2.0 * k * scale * Math.Exp(-2 * r * r) *Math.Sin(2*k) * inverseLength * inverseLength;
    142       yield return 2.0 * scale * Math.Exp(-2 * gradient);
     153      if (!fixedInverseLength) yield return 4.0 * scale * Math.Exp(-2.0 * gradient) * gradient;
     154      if (!fixedPeriod) {
     155        double r = Math.Sin(k) * inverseLength;
     156        yield return 2.0 * k * scale * Math.Exp(-2 * r * r) * Math.Sin(2 * k) * inverseLength * inverseLength;
     157      }
     158      if (!fixedScale)
     159        yield return 2.0 * scale * Math.Exp(-2 * gradient);
    143160
    144161    }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePiecewisePolynomial.cs

    r9543 r10489  
    4545      get { return (IConstrainedValueParameter<IntValue>)Parameters["V"]; }
    4646    }
     47    private bool HasFixedLengthParameter {
     48      get { return LengthParameter.Value != null; }
     49    }
     50    private bool HasFixedScaleParameter {
     51      get { return ScaleParameter.Value != null; }
     52    }
    4753
    4854    [StorableConstructor]
     
    7783    public int GetNumberOfParameters(int numberOfVariables) {
    7884      return
    79         (LengthParameter.Value != null ? 0 : 1) +
    80         (ScaleParameter.Value != null ? 0 : 1);
     85        (HasFixedLengthParameter ? 0 : 1) +
     86        (HasFixedScaleParameter ? 0 : 1);
    8187    }
    8288
     
    9197      // gather parameter values
    9298      int n = 0;
    93       if (LengthParameter.Value != null) {
     99      if (HasFixedLengthParameter) {
    94100        length = LengthParameter.Value.Value;
    95101      } else {
     
    98104      }
    99105
    100       if (ScaleParameter.Value != null) {
     106      if (HasFixedScaleParameter) {
    101107        scale = ScaleParameter.Value.Value;
    102108      } else {
     
    111117      int v = VParameter.Value.Value;
    112118      GetParameterValues(p, out length, out scale);
     119      var fixedLength = HasFixedLengthParameter;
     120      var fixedScale = HasFixedScaleParameter;
    113121      int exp = (int)Math.Floor(columnIndices.Count() / 2.0) + v + 1;
    114122
     
    147155        return scale * Math.Pow(Math.Max(1 - k, 0), exp + v) * f(k);
    148156      };
    149       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, length, scale, v, exp, f, df, columnIndices);
     157      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, length, scale, v, exp, f, df, columnIndices, fixedLength, fixedScale);
    150158      return cov;
    151159    }
    152160
    153     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 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,
     162      bool fixedLength, bool fixedScale) {
    154163      double k = Math.Sqrt(Util.SqrDist(x, i, x, j, 1.0 / length, columnIndices));
    155       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));
    156       yield return 2.0 * scale * Math.Pow(Math.Max(1 - k, 0), exp + v) * f(k);
     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);
    157166    }
    158167  }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePolynomial.cs

    r9535 r10489  
    4545      get { return (IValueParameter<IntValue>)Parameters["Degree"]; }
    4646    }
     47    private bool HasFixedConstParameter {
     48      get { return ConstParameter.Value != null; }
     49    }
     50    private bool HasFixedScaleParameter {
     51      get { return ScaleParameter.Value != null; }
     52    }
    4753
    4854    [StorableConstructor]
     
    7177    public int GetNumberOfParameters(int numberOfVariables) {
    7278      return
    73         (ConstParameter.Value != null ? 0 : 1) +
    74         (ScaleParameter.Value != null ? 0 : 1);
     79        (HasFixedConstParameter ? 0 : 1) +
     80        (HasFixedScaleParameter ? 0 : 1);
    7581    }
    7682
     
    8591      // gather parameter values
    8692      int n = 0;
    87       if (ConstParameter.Value != null) {
     93      if (HasFixedConstParameter) {
    8894        @const = ConstParameter.Value.Value;
    8995      } else {
     
    9298      }
    9399
    94       if (ScaleParameter.Value != null) {
     100      if (HasFixedScaleParameter) {
    95101        scale = ScaleParameter.Value.Value;
    96102      } else {
     
    106112      if (degree <= 0) throw new ArgumentException("The degree parameter for CovariancePolynomial must be greater than zero.");
    107113      GetParameterValues(p, out @const, out scale);
     114      var fixedConst = HasFixedConstParameter;
     115      var fixedScale = HasFixedScaleParameter;
    108116      // create functions
    109117      var cov = new ParameterizedCovarianceFunction();
    110118      cov.Covariance = (x, i, j) => scale * Math.Pow(@const + Util.ScalarProd(x, i, j, 1.0, columnIndices), degree);
    111119      cov.CrossCovariance = (x, xt, i, j) => scale * Math.Pow(@const + Util.ScalarProd(x, i, xt, j, 1.0, columnIndices), degree);
    112       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, @const, scale, degree, columnIndices);
     120      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, @const, scale, degree, columnIndices, fixedConst, fixedScale);
    113121      return cov;
    114122    }
    115123
    116     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double c, double scale, int degree, IEnumerable<int> columnIndices) {
     124    private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double c, double scale, int degree, IEnumerable<int> columnIndices,
     125      bool fixedConst, bool fixedScale) {
    117126      double s = Util.ScalarProd(x, i, j, 1.0, columnIndices);
    118       yield return c * degree * scale * Math.Pow(c + s, degree - 1);
    119       yield return 2 * scale * Math.Pow(c + s, degree);
     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);
    120129    }
    121130  }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceRationalQuadraticArd.cs

    r9456 r10489  
    4545      get { return (IValueParameter<DoubleValue>)Parameters["Shape"]; }
    4646    }
     47    private bool HasFixedScaleParameter {
     48      get { return ScaleParameter.Value != null; }
     49    }
     50    private bool HasFixedInverseLengthParameter {
     51      get { return InverseLengthParameter.Value != null; }
     52    }
     53    private bool HasFixedShapeParameter {
     54      get { return ShapeParameter.Value != null; }
     55    }
    4756
    4857    [StorableConstructor]
     
    7180    public int GetNumberOfParameters(int numberOfVariables) {
    7281      return
    73         (ScaleParameter.Value != null ? 0 : 1) +
    74         (ShapeParameter.Value != null ? 0 : 1) +
    75         (InverseLengthParameter.Value != null ? 0 : numberOfVariables);
     82        (HasFixedScaleParameter ? 0 : 1) +
     83        (HasFixedShapeParameter ? 0 : 1) +
     84        (HasFixedInverseLengthParameter ? 0 : numberOfVariables);
    7685    }
    7786
     
    8897      int c = 0;
    8998      // gather parameter values
    90       if (InverseLengthParameter.Value != null) {
     99      if (HasFixedInverseLengthParameter) {
    91100        inverseLength = InverseLengthParameter.Value.ToArray();
    92101      } else {
    93102        int length = p.Length;
    94         if (ScaleParameter.Value == null) length--;
    95         if (ShapeParameter.Value == null) length--;
     103        if (!HasFixedScaleParameter) length--;
     104        if (!HasFixedShapeParameter) length--;
    96105        inverseLength = p.Select(e => 1.0 / Math.Exp(e)).Take(length).ToArray();
    97106        c += inverseLength.Length;
    98107      }
    99       if (ScaleParameter.Value != null) {
     108      if (HasFixedScaleParameter) {
    100109        scale = ScaleParameter.Value.Value;
    101110      } else {
     
    103112        c++;
    104113      }
    105       if (ShapeParameter.Value != null) {
     114      if (HasFixedShapeParameter) {
    106115        shape = ShapeParameter.Value.Value;
    107116      } else {
     
    116125      double[] inverseLength;
    117126      GetParameterValues(p, out scale, out shape, out inverseLength);
     127      var fixedInverseLength = HasFixedInverseLengthParameter;
     128      var fixedScale = HasFixedScaleParameter;
     129      var fixedShape = HasFixedShapeParameter;
    118130      // create functions
    119131      var cov = new ParameterizedCovarianceFunction();
     
    128140        return scale * Math.Pow(1 + 0.5 * d / shape, -shape);
    129141      };
    130       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, columnIndices, scale, shape, inverseLength);
     142      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, columnIndices, scale, shape, inverseLength, fixedInverseLength, fixedScale, fixedShape);
    131143      return cov;
    132144    }
    133145
    134     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double shape, double[] inverseLength) {
     146    private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double shape, double[] inverseLength,
     147      bool fixedInverseLength, bool fixedScale, bool fixedShape) {
    135148      double d = i == j
    136149                   ? 0.0
     
    138151      double b = 1 + 0.5 * d / shape;
    139152      int k = 0;
    140       foreach (var columnIndex in columnIndices) {
    141         yield return scale * Math.Pow(b, -shape - 1) * Util.SqrDist(x[i, columnIndex] * inverseLength[k], x[j, columnIndex] * inverseLength[k]);
    142         k++;
     153      if (!fixedInverseLength) {
     154        foreach (var columnIndex in columnIndices) {
     155          yield return
     156            scale * Math.Pow(b, -shape - 1) *
     157            Util.SqrDist(x[i, columnIndex] * inverseLength[k], x[j, columnIndex] * inverseLength[k]);
     158          k++;
     159        }
    143160      }
    144       yield return 2 * scale * Math.Pow(b, -shape);
    145       yield return scale * Math.Pow(b, -shape) * (0.5 * d / b - shape * Math.Log(b));
     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));
    146163    }
    147164  }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceRationalQuadraticIso.cs

    r9456 r10489  
    4444      get { return (IValueParameter<DoubleValue>)Parameters["Shape"]; }
    4545    }
     46
     47    private bool HasFixedScaleParameter {
     48      get { return ScaleParameter.Value != null; }
     49    }
     50    private bool HasFixedInverseLengthParameter {
     51      get { return InverseLengthParameter.Value != null; }
     52    }
     53    private bool HasFixedShapeParameter {
     54      get { return ShapeParameter.Value != null; }
     55    }
     56
     57
    4658    [StorableConstructor]
    4759    private CovarianceRationalQuadraticIso(bool deserializing)
     
    6880
    6981    public int GetNumberOfParameters(int numberOfVariables) {
    70       return (ScaleParameter.Value != null ? 0 : 1) +
    71         (ShapeParameter.Value != null ? 0 : 1) +
    72         (InverseLengthParameter.Value != null ? 0 : 1);
     82      return (HasFixedScaleParameter ? 0 : 1) +
     83        (HasFixedShapeParameter ? 0 : 1) +
     84        (HasFixedInverseLengthParameter ? 0 : 1);
    7385    }
    7486
     
    8496      int c = 0;
    8597      // gather parameter values
    86       if (InverseLengthParameter.Value != null) {
     98      if (HasFixedInverseLengthParameter) {
    8799        inverseLength = InverseLengthParameter.Value.Value;
    88100      } else {
     
    90102        c++;
    91103      }
    92       if (ScaleParameter.Value != null) {
     104      if (HasFixedScaleParameter) {
    93105        scale = ScaleParameter.Value.Value;
    94106      } else {
     
    96108        c++;
    97109      }
    98       if (ShapeParameter.Value != null) {
     110      if (HasFixedShapeParameter) {
    99111        shape = ShapeParameter.Value.Value;
    100112      } else {
     
    108120      double scale, shape, inverseLength;
    109121      GetParameterValues(p, out scale, out shape, out inverseLength);
     122      var fixedInverseLength = HasFixedInverseLengthParameter;
     123      var fixedScale = HasFixedScaleParameter;
     124      var fixedShape = HasFixedShapeParameter;
    110125      // create functions
    111126      var cov = new ParameterizedCovarianceFunction();
     
    120135        return scale * Math.Pow(1 + 0.5 * d / shape, -shape);
    121136      };
    122       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, columnIndices, scale, shape, inverseLength);
     137      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, columnIndices, scale, shape, inverseLength, fixedInverseLength, fixedScale, fixedShape);
    123138      return cov;
    124139    }
    125140
    126     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double shape, double inverseLength) {
     141    private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double shape, double inverseLength,
     142      bool fixedInverseLength, bool fixedScale, bool fixedShape) {
    127143      double d = i == j
    128144                   ? 0.0
     
    130146
    131147      double b = 1 + 0.5 * d / shape;
    132       yield return scale * Math.Pow(b, -shape - 1) * d;
    133       yield return 2 * scale * Math.Pow(b, -shape);
    134       yield return scale * Math.Pow(b, -shape) * (0.5 * d / b - shape * Math.Log(b));
     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));
    135151    }
    136152  }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceScale.cs

    r9456 r10489  
    3737      get { return (IValueParameter<DoubleValue>)Parameters["Scale"]; }
    3838    }
     39    private bool HasFixedScaleParameter {
     40      get { return ScaleParameter.Value != null; }
     41    }
    3942
    4043    public IValueParameter<ICovarianceFunction> CovarianceFunctionParameter {
     
    6568
    6669    public int GetNumberOfParameters(int numberOfVariables) {
    67       return (ScaleParameter.Value != null ? 0 : 1) + CovarianceFunctionParameter.Value.GetNumberOfParameters(numberOfVariables);
     70      return (HasFixedScaleParameter ? 0 : 1) + CovarianceFunctionParameter.Value.GetNumberOfParameters(numberOfVariables);
    6871    }
    6972
     
    7780    private void GetParameterValues(double[] p, out double scale) {
    7881      // gather parameter values
    79       if (ScaleParameter.Value != null) {
     82      if (HasFixedScaleParameter) {
    8083        scale = ScaleParameter.Value.Value;
    8184      } else {
     
    8790      double scale;
    8891      GetParameterValues(p, out scale);
     92      var fixedScale = HasFixedScaleParameter;
    8993      var subCov = CovarianceFunctionParameter.Value.GetParameterizedCovarianceFunction(p.Skip(1).ToArray(), columnIndices);
    9094      // create functions
     
    9296      cov.Covariance = (x, i, j) => scale * subCov.Covariance(x, i, j);
    9397      cov.CrossCovariance = (x, xt, i, j) => scale * subCov.CrossCovariance(x, xt, i, j);
    94       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, columnIndices, scale, subCov);
     98      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, columnIndices, scale, subCov, fixedScale);
    9599      return cov;
    96100    }
    97101
    98     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, ParameterizedCovarianceFunction cov) {
    99       yield return 2 * scale * cov.Covariance(x, i, j);
     102    private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, ParameterizedCovarianceFunction cov,
     103      bool fixedScale) {
     104      if (!fixedScale) {
     105        yield return 2 * scale * cov.Covariance(x, i, j);
     106      }
    100107      foreach (var g in cov.CovarianceGradient(x, i, j))
    101108        yield return scale * g;
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSpectralMixture.cs

    r10480 r10489  
    5454    }
    5555
     56    private bool HasFixedWeightParameter {
     57      get { return WeightParameter.Value != null; }
     58    }
     59    private bool HasFixedFrequencyParameter {
     60      get { return FrequencyParameter.Value != null; }
     61    }
     62    private bool HasFixedLengthScaleParameter {
     63      get { return LengthScaleParameter.Value != null; }
     64    }
     65
    5666    [StorableConstructor]
    5767    private CovarianceSpectralMixture(bool deserializing)
     
    8090      var q = QParameter.Value.Value;
    8191      return
    82         (WeightParameter.Value != null ? 0 : q) +
    83         (FrequencyParameter.Value != null ? 0 : q * numberOfVariables) +
    84         (LengthScaleParameter.Value != null ? 0 : q * numberOfVariables);
     92        (HasFixedWeightParameter ? 0 : q) +
     93        (HasFixedFrequencyParameter ? 0 : q * numberOfVariables) +
     94        (HasFixedLengthScaleParameter ? 0 : q * numberOfVariables);
    8595    }
    8696
     
    100110      // guess number of elements for frequency and length (=q * numberOfVariables)
    101111      int n = WeightParameter.Value == null ? ((p.Length - q) / 2) : (p.Length / 2);
    102       if (WeightParameter.Value != null) {
     112      if (HasFixedWeightParameter) {
    103113        weight = WeightParameter.Value.ToArray();
    104114      } else {
     
    106116        c += q;
    107117      }
    108       if (FrequencyParameter.Value != null) {
     118      if (HasFixedFrequencyParameter) {
    109119        frequency = FrequencyParameter.Value.ToArray();
    110120      } else {
     
    112122        c += n;
    113123      }
    114       if (LengthScaleParameter.Value != null) {
     124      if (HasFixedLengthScaleParameter) {
    115125        lengthScale = LengthScaleParameter.Value.ToArray();
    116126      } else {
     
    124134      double[] weight, frequency, lengthScale;
    125135      GetParameterValues(p, out weight, out frequency, out lengthScale);
     136      var fixedWeight = HasFixedWeightParameter;
     137      var fixedFrequency = HasFixedFrequencyParameter;
     138      var fixedLengthScale = HasFixedLengthScaleParameter;
    126139      // create functions
    127140      var cov = new ParameterizedCovarianceFunction();
     
    135148      };
    136149      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, QParameter.Value.Value, weight, frequency,
    137                              lengthScale, columnIndices);
     150                             lengthScale, columnIndices, fixedWeight, fixedFrequency, fixedLengthScale);
    138151      return cov;
    139152    }
     
    168181
    169182    // order of returned gradients must match the order in GetParameterValues!
    170     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 IEnumerable<double> GetGradient(double[,] x, int i, int j, int maxQ, double[] weight, double[] frequency, double[] lengthScale, IEnumerable<int> columnIndices,
     184      bool fixedWeight, bool fixedFrequency, bool fixedLengthScale) {
    171185      double[] tau = Util.GetRow(x, i, columnIndices).Zip(Util.GetRow(x, j, columnIndices), (xi, xj) => xi - xj).ToArray();
    172186      int numberOfVariables = lengthScale.Length / maxQ;
    173187
    174       // weight
    175       // for each component
    176       for (int q = 0; q < maxQ; q++) {
    177         double k = weight[q];
    178         int idx = 0; // helper index for tau
    179         // for each selected variable
    180         foreach (var c in columnIndices) {
    181           k *= f1(tau[idx], lengthScale[q * numberOfVariables + c]) * f2(tau[idx], frequency[q * numberOfVariables + c]);
    182           idx++;
    183         }
    184         yield return k;
    185       }
    186 
    187       // frequency
    188       // for each component
    189       for (int q = 0; q < maxQ; q++) {
    190         int idx = 0; // helper index for tau
    191         // for each selected variable
    192         foreach (var c in columnIndices) {
    193           double k = f1(tau[idx], lengthScale[q * numberOfVariables + c]) *
    194             -2 * Math.PI * tau[idx] * frequency[q * numberOfVariables + c] * Math.Sin(2 * Math.PI * tau[idx] * frequency[q * numberOfVariables + c]);
    195           idx++;
    196           yield return weight[q] * k;
    197         }
    198       }
    199 
    200       // length scale
    201       // for each component
    202       for (int q = 0; q < maxQ; q++) {
    203         int idx = 0; // helper index for tau
    204         // for each selected variable
    205         foreach (var c in columnIndices) {
    206           double k = -2 * Math.PI * Math.PI * tau[idx] * tau[idx] * lengthScale[q * numberOfVariables + c] *
    207              f1(tau[idx], lengthScale[q * numberOfVariables + c]) * f2(tau[idx], frequency[q * numberOfVariables + c]);
    208           idx++;
    209           yield return weight[q] * k;
    210         }
    211       }
    212 
     188      if (!fixedWeight) {
     189        // weight
     190        // for each component
     191        for (int q = 0; q < maxQ; q++) {
     192          double k = weight[q];
     193          int idx = 0; // helper index for tau
     194          // 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]);
     197            idx++;
     198          }
     199          yield return k;
     200        }
     201      }
     202
     203      if (!fixedFrequency) {
     204        // frequency
     205        // for each component
     206        for (int q = 0; q < maxQ; q++) {
     207          int idx = 0; // helper index for tau
     208          // for each selected variable
     209          foreach (var c in columnIndices) {
     210            double k = f1(tau[idx], lengthScale[q * numberOfVariables + c]) *
     211                       -2 * Math.PI * tau[idx] * frequency[q * numberOfVariables + c] *
     212                       Math.Sin(2 * Math.PI * tau[idx] * frequency[q * numberOfVariables + c]);
     213            idx++;
     214            yield return weight[q] * k;
     215          }
     216        }
     217      }
     218
     219      if (!fixedLengthScale) {
     220        // length scale
     221        // for each component
     222        for (int q = 0; q < maxQ; q++) {
     223          int idx = 0; // helper index for tau
     224          // for each selected variable
     225          foreach (var c in columnIndices) {
     226            double k = -2 * Math.PI * Math.PI * tau[idx] * tau[idx] * lengthScale[q * numberOfVariables + c] *
     227                       f1(tau[idx], lengthScale[q * numberOfVariables + c]) *
     228                       f2(tau[idx], frequency[q * numberOfVariables + c]);
     229            idx++;
     230            yield return weight[q] * k;
     231          }
     232        }
     233      }
    213234    }
    214235  }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSquaredExponentialArd.cs

    r9456 r10489  
    4040      get { return (IValueParameter<DoubleArray>)Parameters["InverseLength"]; }
    4141    }
     42    private bool HasFixedInverseLengthParameter {
     43      get { return InverseLengthParameter.Value != null; }
     44    }
     45    private bool HasFixedScaleParameter {
     46      get { return ScaleParameter.Value != null; }
     47    }
    4248
    4349    [StorableConstructor]
     
    6167    public int GetNumberOfParameters(int numberOfVariables) {
    6268      return
    63         (ScaleParameter.Value != null ? 0 : 1) +
    64         (InverseLengthParameter.Value != null ? 0 : numberOfVariables);
     69        (HasFixedScaleParameter ? 0 : 1) +
     70        (HasFixedInverseLengthParameter ? 0 : numberOfVariables);
    6571    }
    6672
     
    7682      int c = 0;
    7783      // gather parameter values
    78       if (InverseLengthParameter.Value != null) {
     84      if (HasFixedInverseLengthParameter) {
    7985        inverseLength = InverseLengthParameter.Value.ToArray();
    8086      } else {
    8187        int length = p.Length;
    82         if (ScaleParameter.Value == null) length--;
     88        if (HasFixedScaleParameter) length--;
    8389        inverseLength = p.Select(e => 1.0 / Math.Exp(e)).Take(length).ToArray();
    8490        c += inverseLength.Length;
    8591      }
    86       if (ScaleParameter.Value != null) {
     92      if (HasFixedScaleParameter) {
    8793        scale = ScaleParameter.Value.Value;
    8894      } else {
     
    97103      double[] inverseLength;
    98104      GetParameterValues(p, out scale, out inverseLength);
     105      var fixedInverseLength = HasFixedInverseLengthParameter;
     106      var fixedScale = HasFixedScaleParameter;
    99107      // create functions
    100108      var cov = new ParameterizedCovarianceFunction();
     
    109117        return scale * Math.Exp(-d / 2.0);
    110118      };
    111       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, columnIndices, scale, inverseLength);
     119      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, columnIndices, scale, inverseLength, fixedInverseLength, fixedScale);
    112120      return cov;
    113121    }
    114122
    115123    // order of returned gradients must match the order in GetParameterValues!
    116     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double[] inverseLength) {
     124    private static IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices, double scale, double[] inverseLength,
     125      bool fixedInverseLength, bool fixedScale) {
    117126      double d = i == j
    118127                   ? 0.0
     
    120129
    121130      int k = 0;
    122       foreach (var columnIndex in columnIndices) {
    123         double sqrDist = Util.SqrDist(x[i, columnIndex] * inverseLength[k], x[j, columnIndex] * inverseLength[k]);
    124         yield return scale * Math.Exp(-d / 2.0) * sqrDist;
    125         k++;
     131      if (!fixedInverseLength) {
     132        foreach (var columnIndex in columnIndices) {
     133          double sqrDist = Util.SqrDist(x[i, columnIndex] * inverseLength[k], x[j, columnIndex] * inverseLength[k]);
     134          yield return scale * Math.Exp(-d / 2.0) * sqrDist;
     135          k++;
     136        }
    126137      }
    127       yield return 2.0 * scale * Math.Exp(-d / 2.0);
     138      if (!fixedScale) yield return 2.0 * scale * Math.Exp(-d / 2.0);
    128139    }
    129140  }
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSquaredExponentialIso.cs

    r9456 r10489  
    4242    }
    4343
     44    private bool HasFixedInverseLengthParameter {
     45      get { return InverseLengthParameter.Value != null; }
     46    }
     47    private bool HasFixedScaleParameter {
     48      get { return ScaleParameter.Value != null; }
     49    }
     50
    4451    [StorableConstructor]
    4552    private CovarianceSquaredExponentialIso(bool deserializing)
     
    6673    public int GetNumberOfParameters(int numberOfVariables) {
    6774      return
    68         (ScaleParameter.Value != null ? 0 : 1) +
    69         (InverseLengthParameter.Value != null ? 0 : 1);
     75        (HasFixedScaleParameter ? 0 : 1) +
     76        (HasFixedInverseLengthParameter ? 0 : 1);
    7077    }
    7178
     
    8188      // gather parameter values
    8289      int c = 0;
    83       if (InverseLengthParameter.Value != null) {
     90      if (HasFixedInverseLengthParameter) {
    8491        inverseLength = InverseLengthParameter.Value.Value;
    8592      } else {
     
    8895      }
    8996
    90       if (ScaleParameter.Value != null) {
     97      if (HasFixedScaleParameter) {
    9198        scale = ScaleParameter.Value.Value;
    9299      } else {
     
    100107      double inverseLength, scale;
    101108      GetParameterValues(p, out scale, out inverseLength);
     109      var fixedInverseLength = HasFixedInverseLengthParameter;
     110      var fixedScale = HasFixedScaleParameter;
    102111      // create functions
    103112      var cov = new ParameterizedCovarianceFunction();
     
    112121        return scale * Math.Exp(-d / 2.0);
    113122      };
    114       cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, scale, inverseLength, columnIndices);
     123      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, scale, inverseLength, columnIndices,
     124        fixedInverseLength, fixedScale);
    115125      return cov;
    116126    }
    117127
    118128    // order of returned gradients must match the order in GetParameterValues!
    119     private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double sf2, double inverseLength, IEnumerable<int> columnIndices) {
     129    private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double sf2, double inverseLength, IEnumerable<int> columnIndices,
     130      bool fixedInverseLength, bool fixedScale) {
    120131      double d = i == j
    121132                   ? 0.0
    122133                   : Util.SqrDist(x, i, j, inverseLength, columnIndices);
    123134      double g = Math.Exp(-d / 2.0);
    124       yield return sf2 * g * d;
    125       yield return 2.0 * sf2 * g;
     135      if (!fixedInverseLength) yield return sf2 * g * d;
     136      if (!fixedScale) yield return 2.0 * sf2 * g;
    126137    }
    127138  }
Note: See TracChangeset for help on using the changeset viewer.