public MatrixValue Function(ArgumentsValue values) { var m = new MatrixValue(); for (var i = 1; i <= values.Length; i++) { var sy = m.DimensionY; var sx = m.DimensionX; if (values[i] is ScalarValue) { var s = (ScalarValue)values[i]; m[sy + 1, sx + 1] = s.Clone(); } else if (values[i] is MatrixValue) { var n = (MatrixValue)values[i]; for (var l = 1; l <= n.DimensionX; l++) { for (var k = 1; k <= n.DimensionY; k++) { m[sy + k, sx + l] = n[k, l].Clone(); } } } else { throw new YAMPArgumentInvalidException(Name, values[i].Header, i); } } return(m); }
public ArgumentsValue Function(StringValue text, ArgumentsValue args) { var separators = args.Select(v => v.ToString()).ToArray(); var tokens = text.ToString().Split(separators, StringSplitOptions.RemoveEmptyEntries); return(new ArgumentsValue(tokens.Select(s => new StringValue(s)).ToArray())); }
/// <summary> /// Create a new instance from the given binary content. /// </summary> /// <param name="content">The content in bytes.</param> /// <returns>The new instance.</returns> public override Value Deserialize(byte[] content) { var A = new ArgumentsValue(); using (var ms = new MemoryStream(content)) { var buffer = new byte[4]; ms.Read(buffer, 0, buffer.Length); var count = BitConverter.ToInt32(buffer, 0); for (var i = 0; i < count; i++) { ms.Read(buffer, 0, buffer.Length); var length = BitConverter.ToInt32(buffer, 0); var stringBuffer = new byte[length]; ms.Read(stringBuffer, 0, stringBuffer.Length); var name = Encoding.UTF8.GetString(stringBuffer, 0, stringBuffer.Length); ms.Read(buffer, 0, buffer.Length); length = BitConverter.ToInt32(buffer, 0); var contentBuffer = new byte[length]; ms.Read(contentBuffer, 0, contentBuffer.Length); A._values.Add(Deserialize(name, contentBuffer)); } } return(A); }
/// <summary> /// Creates a new ArgumentsValue with 2 values. /// </summary> /// <param name="left">The first value to include.</param> /// <param name="right">The second value to include.</param> /// <returns>The new ArgumentsValue instance.</returns> public static ArgumentsValue Create(Value left, Value right) { var a = new ArgumentsValue(); a.Append(left).Append(right); return(a); }
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(FunctionValue deq, MatrixValue points, ScalarValue x0) { Func <double, double, double> lambda = (t, x) => { var av = new ArgumentsValue(new ScalarValue(t), new ScalarValue(x)); var sv = deq.Perform(Context, av); if (!(sv is ScalarValue)) { throw new YAMPArgumentInvalidException(Name, sv.Header, 1); } return(((ScalarValue)sv).Re); }; var euler = new RungeKutta(lambda, points[1].Re, points[points.Length].Re, x0.Re, points.Length - 1); return(new MatrixValue(euler.Result)); }
void SetPerform(String name, String[] arguments, Expression body) { _perform = (context, argument) => { var symbols = new Dictionary <String, Value>(); var av = new ArgumentsValue().Append(argument); if (av.Length != arguments.Length) { throw new YAMPArgumentNumberException(name, av.Length, arguments.Length); } for (var i = 0; i < arguments.Length; i++) { symbols.Add(arguments[i], av.Values[i].Copy()); } return(body.Interpret(symbols)); }; }
public Plot2DValue Function(MatrixValue m, MatrixValue n, ArgumentsValue l) { var plot = new Plot2DValue(); var values = new MatrixValue[l.Length]; for (var i = 0; i != l.Length; i++) { if (l.Values[i] is MatrixValue) { values[i] = (MatrixValue)l.Values[i]; } else { throw new YAMPOperationInvalidException("plot", l.Values[i]); } } plot.AddPoints(m, n, values); return(plot); }
public void Function(StringValue fileName, ArgumentsValue args) { var workspace = new Dictionary <string, Value>(); foreach (var arg in args.Values) { if (arg is StringValue) { var name = (arg as StringValue).Value; if (Context.Variables.ContainsKey(name)) { workspace.Add(name, Context.Variables[name]); } } } Save(fileName.Value, workspace); Notify(workspace.Count); }
public void Function(ArgumentsValue args) { var count = 0; var allVariables = Context.AllVariables.Keys; foreach (var arg in args.Values) { if (arg is StringValue) { var name = (arg as StringValue).Value; if (allVariables.Contains(name)) { Context.AssignVariable(name, null); count++; } } } Notify(count); }
public StringValue Function(ArgumentsValue filter) { var values = filter.Values; int index = 0; var sb = new StringBuilder(); foreach (var value in values) { index++; if (value is StringValue) { var str = value as StringValue; sb.Append(Function(str)); } else { throw new YAMPArgumentWrongTypeException(value.Header, "String", Name); } } return(new StringValue(sb.ToString())); }
public void Function(StringValue filename, ArgumentsValue args) { if (!File.Exists(filename.Value)) { throw new YAMPFileNotFoundException(filename.Value); } var error = false; var v = Load(filename.Value, out error); var count = 0; if (!error) { foreach (var arg in args.Values) { if (arg is StringValue) { var name = (arg as StringValue).Value; if (v.ContainsKey(name)) { Context.AssignVariable(name, v[name] as Value); count++; } } } } if (error) { var table = ImageLoad(filename.Value, out error); if (!error) { var name = "image"; if (args.Length > 0 && args.Values[0] is StringValue) { name = (args.Values[0] as StringValue).Value; } else { var suffix = -1; do { suffix++; }while (Context.Variables.ContainsKey(name + suffix)); name = name + suffix; } Context.AssignVariable(name, table); count = 1; } } if (error) { var table = ASCIILoad(filename.Value, out error); if (!error) { var name = "data"; if (args.Length > 0 && args.Values[0] is StringValue) { name = (args.Values[0] as StringValue).Value; } else { var suffix = -1; do { suffix++; }while (Context.Variables.ContainsKey(name + suffix)); name = name + suffix; } Context.AssignVariable(name, table); count = 1; } } if (error) { throw new YAMPFileFormatNotSupportedException(filename.Value); } Notify(count); }
/// <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 }
public override Value Perform(Value left, Value right) { return(ArgumentsValue.Create(left, right)); }
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 void Function(StringValue text, ArgumentsValue args) { var content = string.Format(text.Value, args.ToArray()); Parser.RaiseNotification(Context, new NotificationEventArgs(NotificationType.Message, content)); }
public StringValue Function(StringValue text, ArgumentsValue args) { return(new StringValue(string.Format(text.Value, args.ToArray()))); }
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); }