static ComplexPlotValue Plot(FunctionValue f, Double minx, Double maxx, Double miny, Double maxy) { var cp = new ComplexPlotValue(); cp.SetFunction(f); cp.MinY = miny; cp.MaxY = maxy; cp.MinX = minx; cp.MaxX = maxx; return cp; }
public ScalarValue Function(FunctionValue f, ScalarValue x) { var lambda = new Func<Double, Double>(t => { var sv = f.Perform(Context, new ScalarValue(t)); if (sv is ScalarValue == false) { throw new YAMPArgumentInvalidException(Name, sv.Header, 1); } return ((ScalarValue)sv).Re; }); var newton = new NewtonMethod(lambda, x.Re, 0.00001); return new ScalarValue(newton.Result[0, 0]); }
public FunctionValue Function(MatrixValue x, MatrixValue y, FunctionValue f) { var context = Context; if (x.Length != y.Length) throw new YAMPDifferentLengthsException(x.Length, y.Length); var _fx = f.Perform(context, x[1]); if (_fx is MatrixValue == false) throw new YAMPArgumentInvalidException("Linfit", "f", 3); var fx = _fx as MatrixValue; var m = fx.Length; if (m < 2) throw new YAMPArgumentInvalidException("Linfit", "f", 3); var M = new MatrixValue(x.Length, m); for (var j = 1; j <= M.Rows; j++) { if (j > 1) { fx = f.Perform(context, x[j]) as MatrixValue; } for (var i = 1; i <= M.Columns; i++) { M[j, i] = fx[i]; } } var p = Function(x, y, M); return new FunctionValue((parseContext, variable) => ((f.Perform(parseContext, variable) as MatrixValue) * p)[1], true); }
public Plot2DValue Function(FunctionValue f, ScalarValue min, ScalarValue max, ScalarValue precision) { return(Plot(f, min.Re, max.Re, precision.Re)); }
/// <summary> /// Sets the function to use for the complex plot. /// </summary> /// <param name="function">The function to consider.</param> public void SetFunction(FunctionValue function) { f = function; }
public FunctionValue Function(MatrixValue Y, ScalarValue nbins, ScalarValue nParameters) { var nn = nbins.GetIntegerOrThrowException("nbins", Name); var nP = nParameters.GetIntegerOrThrowException("nParameters", Name); var N = Y.Length; var min_idx = Y.Min(); var min = Y[min_idx.Row, min_idx.Column]; var max_idx = Y.Max(); var max = Y[max_idx.Row, max_idx.Column]; var median = YMath.Median(Y); var variance = ScalarValue.Zero; var mean = Y.Sum() / Y.Length; for (var i = 1; i <= Y.Length; i++) { variance += (Y[i] - mean).Square(); } variance /= Y.Length; var delta = (max - min) / nn; var x = new MatrixValue(nn, 1); for (var i = 0; i < nn; i++) { x[i + 1] = min + delta * i; } var histogram = new HistogramFunction(); var fx = histogram.Function(Y, x); var linearfit = new LinfitFunction(Context); var dist = linearfit.Function(x, fx, new FunctionValue((context, argument) => { var _x = (argument as ScalarValue - median / 2) / (variance / 4); var _exp_x_2 = (-_x * _x).Exp(); var result = new MatrixValue(1, nP - 1); for (var i = 0; i < nP - 1; i++) { result[i + 1] = _exp_x_2 * _x.Pow(new ScalarValue(i)); } return result; }, true)); var norm = Y.Length * (max - min) / nbins; var normed_dist = new FunctionValue((context, argument) => { var temp = dist.Perform(context, argument); if (temp is ScalarValue) { return ((ScalarValue)temp) / norm; } else if (temp is MatrixValue) { return ((MatrixValue)temp) / norm; } throw new YAMPOperationInvalidException(); }, true); return normed_dist; }
public MatrixValue Function(MatrixValue cfgs, ScalarValue n, FunctionValue f, ArgumentsValue P) { var numberOfBootstrapSamples = n.GetIntegerOrThrowException("n", Name); var nConfigs = cfgs.DimensionY; var nData = cfgs.DimensionX; var distribution = new DiscreteUniformDistribution(Rng) { Beta = nConfigs, Alpha = 1 }; if (numberOfBootstrapSamples <= 1) throw new YAMPException("Bootstrap: The number of bootstrap samples n is smaller or equal to 1!"); var parameters = new ArgumentsValue(cfgs); foreach (var m in P.Values) { parameters.Insert(m); } var temp = f.Perform(Context, parameters); var nResult = 0;//dimension of the result if (temp is ScalarValue) { nResult = 1; } else if (temp is MatrixValue) { nResult = ((MatrixValue)temp).Length; } else { throw new YAMPException("Bootstrap: The observable f has to return either a scalar or a matrix!"); } var BootstrapObservable = new MatrixValue(numberOfBootstrapSamples, nResult); for (var i = 1; i <= numberOfBootstrapSamples; i++) { var BootstrapConfigs = new MatrixValue(nConfigs, nData); for (var j = 1; j <= nConfigs; j++) { var idx = distribution.Next(); for (var k = 1; k <= nData; k++) { BootstrapConfigs[j, k] = cfgs[idx, k]; } } parameters = new ArgumentsValue(BootstrapConfigs); foreach (var m in P.Values) { parameters.Insert(m); } temp = f.Perform(Context, parameters); if (temp is ScalarValue) { BootstrapObservable[i] = (ScalarValue)temp; } else { var m = (MatrixValue)temp; for (var k = 1; k <= nResult; k++) { BootstrapObservable[i, k] = m[k]; } } } temp = YMath.Average(BootstrapObservable); for (var i = 1; i <= numberOfBootstrapSamples; i++) { if (temp is ScalarValue) { BootstrapObservable[i] -= temp as ScalarValue; BootstrapObservable[i] *= BootstrapObservable[i]; } else { var T = temp as MatrixValue; for (var k = 1; k <= nResult; k++) { BootstrapObservable[i, k] -= T[k]; BootstrapObservable[i, k] *= BootstrapObservable[i, k]; } } } var error = YMath.Average(BootstrapObservable); var sqrt = new SqrtFunction(); error = sqrt.Perform(error); var result = new MatrixValue(2, nResult); if (temp is ScalarValue) { result[1] = (ScalarValue)temp; result[2] = (ScalarValue)error; } else { var T = (MatrixValue)temp; var E = (MatrixValue)error; for (var k = 1; k <= nResult; k++) { result[1, k] = T[k]; result[2, k] = E[k]; } } return result; }
public MatrixValue Function(MatrixValue cfgs, ScalarValue n, FunctionValue f) { return Function(cfgs, n, f, new ArgumentsValue()); }
public MatrixValue Function(MatrixValue cfgs, ScalarValue n, FunctionValue f, ArgumentsValue P) { var numberOfBlocks = n.GetIntegerOrThrowException("n", Name); var nConfigs = cfgs.DimensionY; var nData = cfgs.DimensionX; if (numberOfBlocks > nConfigs) { throw new YAMPException("Jackknife: The number of measurements n is greater than the number of configurations cfgs!"); } if (numberOfBlocks <= 1) { throw new YAMPException("Jackknife: The number of measurements n <= 1!"); } var parameters = new ArgumentsValue(cfgs); foreach (var m in P.Values) { parameters.Insert(m); } var temp = f.Perform(Context, parameters); int nResult;//dimension of the result if (temp is ScalarValue) { nResult = 1; } else if (temp is MatrixValue) { nResult = (temp as MatrixValue).Length; } else { throw new YAMPException("Jackknife: Observable f has to return either a scalar or a matrix!"); } var JackknifeObservable = new MatrixValue(numberOfBlocks, nResult); var BlockSize = nConfigs / numberOfBlocks; var nConfigsBlocked = BlockSize * numberOfBlocks; var residualConfigs = nConfigs - nConfigsBlocked; for (int i = 1; i <= numberOfBlocks; i++) { if (i <= numberOfBlocks - residualConfigs) { //the first (NumberOfBlocks - residualConfigs) blocks discard (BlockSize) elements ... var JackknifeConfigs = new MatrixValue(nConfigs - BlockSize, nData); int j = 1; for (; j <= (i - 1) * BlockSize; j++) { for (int k = 1; k <= nData; k++) { JackknifeConfigs[j, k] = cfgs[j, k]; } } j += BlockSize; for (; j <= nConfigs; j++) { for (int k = 1; k <= nData; k++) { JackknifeConfigs[j - BlockSize, k] = cfgs[j, k]; } } parameters = new ArgumentsValue(JackknifeConfigs); } else { //... whereas the residual (residualConfigs) blocks discard (BlockSize + 1) elements var JackknifeConfigs = new MatrixValue(nConfigs - BlockSize - 1, nData); int j = 1; for (; j <= nConfigs - (numberOfBlocks - (i - 1)) * (BlockSize + 1); j++) { for (int k = 1; k <= nData; k++) { JackknifeConfigs[j, k] = cfgs[j, k]; } } j += BlockSize + 1; for (; j <= nConfigs; j++) { for (int k = 1; k <= nData; k++) { JackknifeConfigs[j - BlockSize - 1, k] = cfgs[j, k]; } } parameters = new ArgumentsValue(JackknifeConfigs); } foreach (var m in P.Values) { parameters.Insert(m); } temp = f.Perform(Context, parameters); if (temp is ScalarValue) { JackknifeObservable[i] = (ScalarValue)temp; } else { var T = (MatrixValue)temp; for (int k = 1; k <= nResult; k++) { JackknifeObservable[i, k] = T[k]; } } } temp = YMath.Average(JackknifeObservable); for (int i = 1; i <= numberOfBlocks; i++) { if (temp is ScalarValue) { JackknifeObservable[i] -= temp as ScalarValue; JackknifeObservable[i] *= JackknifeObservable[i]; } else { var m = (MatrixValue)temp; for (int k = 1; k <= nResult; k++) { JackknifeObservable[i, k] -= m[k]; JackknifeObservable[i, k] *= JackknifeObservable[i, k]; } } } var error = YMath.Average(JackknifeObservable); var scale = numberOfBlocks - 1.0; if (error is ScalarValue) { error = ((ScalarValue)error) * scale; } else { var e = (MatrixValue)error; for (var i = 1; i <= e.DimensionY; i++) { for (int j = 1; j <= e.DimensionX; j++) { e[i, j] *= scale; } } } var sqrt = new SqrtFunction(); error = sqrt.Perform(error); var result = new MatrixValue(2, nResult); if (temp is ScalarValue) { result[1] = (ScalarValue)temp; result[2] = (ScalarValue)error; } else { var T = (MatrixValue)temp; var E = (MatrixValue)error; for (int k = 1; k <= nResult; k++) { result[1, k] = T[k]; result[2, k] = E[k]; } } return(result); }
public ComplexPlotValue Function(FunctionValue f, ScalarValue minX, ScalarValue maxX, ScalarValue minY, ScalarValue maxY) { return Plot(f, minX.Re, maxX.Re, minY.Re, maxY.Re); }
public ComplexPlotValue Function(FunctionValue f) { return Plot(f, -1.0, 1.0, -1.0, 1.0); }
public Plot2DValue Function(FunctionValue f) { return(Plot(f, -1.0, 1.0, 0.05)); }
public Plot2DValue Function(FunctionValue f, ScalarValue min, ScalarValue max) { return(Plot(f, min.Re, max.Re, 0.05)); }
public FunctionValue Function(MatrixValue Y, ScalarValue nbins, ScalarValue nParameters) { var nn = nbins.GetIntegerOrThrowException("nbins", Name); var nP = nParameters.GetIntegerOrThrowException("nParameters", Name); var N = Y.Length; var min_idx = Y.Min(); var min = Y[min_idx.Row, min_idx.Column]; var max_idx = Y.Max(); var max = Y[max_idx.Row, max_idx.Column]; var median = YMath.Median(Y); var variance = ScalarValue.Zero; var mean = Y.Sum() / Y.Length; for (var i = 1; i <= Y.Length; i++) { variance += (Y[i] - mean).Square(); } variance /= Y.Length; var delta = (max - min) / nn; var x = new MatrixValue(nn, 1); for (var i = 0; i < nn; i++) { x[i + 1] = min + delta * i; } var histogram = new HistogramFunction(); var fx = histogram.Function(Y, x); var linearfit = new LinfitFunction(Context); var dist = linearfit.Function(x, fx, new FunctionValue((context, argument) => { var _x = (argument as ScalarValue - median / 2) / (variance / 4); var _exp_x_2 = (-_x * _x).Exp(); var result = new MatrixValue(1, nP - 1); for (var i = 0; i < nP - 1; i++) { result[i + 1] = _exp_x_2 * _x.Pow(new ScalarValue(i)); } return(result); }, true)); var norm = Y.Length * (max - min) / nbins; var normed_dist = new FunctionValue((context, argument) => { var temp = dist.Perform(context, argument); if (temp is ScalarValue) { return(((ScalarValue)temp) / norm); } else if (temp is MatrixValue) { return(((MatrixValue)temp) / norm); } throw new YAMPOperationInvalidException(); }, true); return(normed_dist); }
public ComplexPlotValue Function(FunctionValue f, ScalarValue minX, ScalarValue maxX, ScalarValue minY, ScalarValue maxY) { return(Plot(f, minX.Re, maxX.Re, minY.Re, maxY.Re)); }
public ComplexPlotValue Function(FunctionValue f, ScalarValue min, ScalarValue max) { return(Plot(f, min.Re, max.Re, min.Im, max.Im)); }
public ComplexPlotValue Function(FunctionValue f) { return(Plot(f, -1.0, 1.0, -1.0, 1.0)); }
public override Value Interpret(IDictionary<String, Value> symbols) { var f = new FunctionValue(Name, Arguments, Body.Container); Query.Context.AddFunction(Name, f); return f; }
public Plot2DValue Function(FunctionValue f) { return Plot(f, -1.0, 1.0, 0.05); }
public ComplexPlotValue Function(FunctionValue f, ScalarValue min, ScalarValue max) { return Plot(f, min.Re, max.Re, min.Im, max.Im); }
public Plot2DValue Function(FunctionValue f, ScalarValue min, ScalarValue max) { return Plot(f, min.Re, max.Re, 0.05); }
public Plot2DValue Function(FunctionValue f, ScalarValue min, ScalarValue max, ScalarValue precision) { return Plot(f, min.Re, max.Re, precision.Re); }
public MatrixValue Function(MatrixValue cfgs, ScalarValue n, FunctionValue f) { return(Function(cfgs, n, f, new ArgumentsValue())); }