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
}
