YAMPRuntimeException BuildArguments(FunctionParameters yp) { var attrs = yp.OptionalArguments; var values = new List <Value>(); for (var i = 0; i < _arguments.Length; i++) { var opt = false; for (var j = 0; j < attrs.Length; j++) { var attr = attrs[j]; if (attr.Index == i) { var rest = _arguments.Length - i; if (rest >= attr.MinimumArguments) { var av = new ArgumentsValue(); var pt = Math.Min(attr.MaximumArguments / attr.StepArguments, rest / attr.StepArguments); for (var k = 0; k < pt; k++) { for (var l = 0; l < attr.StepArguments; l++) { av.Insert(_arguments[i++]); } } values.Add(av); opt = true; } } } if (!opt) { var idx = values.Count; if (!yp.ParameterTypes[idx].IsInstanceOfType(_arguments[idx])) { return(new YAMPArgumentInvalidException(Name, _arguments[idx].Header, yp.ParameterTypes[idx].Name.RemoveValueConvention(), idx)); } values.Add(_arguments[i]); } } while (values.Count < yp.ParameterTypes.Length) { values.Add(new ArgumentsValue()); } _arguments = values.ToArray(); return(null); }
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, 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 = ((MatrixValue)temp).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 (var i = 1; i <= numberOfBlocks; i++) { if (i <= numberOfBlocks - residualConfigs) { //the first (NumberOfBlocks - residualConfigs) blocks discard (BlockSize) elements ... var JackknifeConfigs = new MatrixValue(nConfigs - BlockSize, nData); var j = 1; for (; j <= (i - 1) * BlockSize; j++) { for (var k = 1; k <= nData; k++) { JackknifeConfigs[j, k] = cfgs[j, k]; } } j += BlockSize; for (; j <= nConfigs; j++) { for (var 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); var j = 1; for (; j <= nConfigs - (numberOfBlocks - (i - 1)) * (BlockSize + 1); j++) { for (var k = 1; k <= nData; k++) { JackknifeConfigs[j, k] = cfgs[j, k]; } } j += BlockSize + 1; for (; j <= nConfigs; j++) { for (var 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 (var k = 1; k <= nResult; k++) { JackknifeObservable[i, k] = T[k]; } } } temp = YMath.Average(JackknifeObservable); for (var i = 1; i <= numberOfBlocks; i++) { if (temp is ScalarValue) { JackknifeObservable[i] -= temp as ScalarValue; JackknifeObservable[i] *= JackknifeObservable[i]; } else { var m = (MatrixValue)temp; for (var 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 (var 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 (var k = 1; k <= nResult; k++) { result[1, k] = T[k]; result[2, k] = E[k]; } } return(result); }
/// <summary> /// Performs the function execution. /// </summary> /// <param name="argument">The argument(s) (if presented in an "ArgumentValue").</param> /// <returns>The evaluated value.</returns> public override Value Perform(Value argument) { if (argument is ArgumentsValue) { arguments = (argument as ArgumentsValue).Values; } else { arguments = new Value[] { argument } }; return(Execute()); } #endregion #region Helpers Value Execute() { var args = arguments.Length; var difference = int.MaxValue; var expected = 0; YAMPRuntimeException exception = null; foreach (var kv in functions) { var key = kv.Key; if (args < key.MinimumArguments || args > key.MaximumArguments) { var diff = Math.Min(Math.Abs(key.MinimumArguments - args), Math.Abs(args - key.MaximumArguments)); if (diff < difference) { difference = diff; expected = args < key.MinimumArguments ? key.MinimumArguments : key.MaximumArguments; } continue; } var f = kv.Value; exception = BuildArguments(key); if (exception == null) { try { return(f.Invoke(this, arguments) as Value); } catch (Exception ex) { if (ex.InnerException != null) { throw ex.InnerException; } throw; } } } if (exception != null) { throw exception; } throw new YAMPArgumentNumberException(Name, args, expected); } YAMPRuntimeException BuildArguments(FunctionParameters yp) { var attrs = yp.OptionalArguments; var values = new List <Value>(); for (var i = 0; i < arguments.Length; i++) { var opt = false; for (var j = 0; j < attrs.Length; j++) { var attr = attrs[j]; if (attr.Index == i) { var rest = arguments.Length - i; if (rest >= attr.MinimumArguments) { var av = new ArgumentsValue(); var pt = Math.Min(attr.MaximumArguments / attr.StepArguments, rest / attr.StepArguments); for (var k = 0; k < pt; k++) { for (var l = 0; l < attr.StepArguments; l++) { av.Insert(arguments[i++]); } } values.Add(av); opt = true; } } } if (!opt) { var idx = values.Count; if (!yp.ParameterTypes[idx].IsInstanceOfType(arguments[idx])) { return(new YAMPArgumentInvalidException(Name, arguments[idx].Header, yp.ParameterTypes[idx].Name.RemoveValueConvention(), idx)); } values.Add(arguments[i]); } } while (values.Count < yp.ParameterTypes.Length) { values.Add(new ArgumentsValue()); } arguments = values.ToArray(); return(null); } #endregion }