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);
}
