public TypeMatch TemplateMatchesInput(ComputationContext ctx, EntityInstance input,
VarianceMode variance, TypeMatching matching)
{
// todo: this is correct but it is just a hack really, because we should check constraints
// and if they are compatible we should return match
if (input.TargetsTemplateParameter && this.TargetsTemplateParameter &&
!input.TargetTemplate.Constraints.Any() && !this.TargetTemplate.Constraints.Any())
{
return(TypeMatch.Same);
}
matching.Position = matching.Position.Flipped(variance);
switch (matching.Position)
{
case VarianceMode.None:
return(this.IsExactlySame(input, jokerMatchesAll: true) ? TypeMatch.Same : TypeMatch.No);
case VarianceMode.In:
return(TypeMatcher.Matches(ctx, this, input, matching));
case VarianceMode.Out:
return(TypeMatcher.Matches(ctx, input, this, matching));
}
throw new NotImplementedException();
}
public static StdDevInfo Calculate(IReadOnlyList<double> samples, VarianceMode varianceMode, VarianceAlgorithm varianceAlgorithm)
{
var std_dev = new StdDevInfo();
std_dev.Variance = Variance.Calculate(samples, varianceMode, varianceAlgorithm);
return std_dev;
}
/// <summary>
/// Calculates a Variance of a sample (set of numbers).
/// </summary>
/// <remarks>
/// https://en.wikipedia.org/wiki/Variance
/// Variance measures how far the set of numbers are spread out.
/// Variance == 0 indicates that all numbers are identical.
/// Variance is always non-negative.
/// Variance close to 0 indicates that the numbers tend to be very close to the mean (and hence to each other).
/// </remarks>
/// <param name="samples">array of samples</param>
/// <param name="mode">calculation mode (biased or unbiased)</param>
/// <param name="algorithm">algorithm to use for calculations</param>
public static VarianceInfo Calculate(IReadOnlyList<double> samples, VarianceMode mode, VarianceAlgorithm algorithm)
{
if (mode == VarianceMode.Biased && samples.Count <= 0)
return VarianceInfo.NaN;
else if (mode == VarianceMode.Unbiased && samples.Count <= 1)
return VarianceInfo.NaN;
//# https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
var partial_variance_info = new VarianceInfo();
if (algorithm == VarianceAlgorithm.Online)
partial_variance_info = M1M2_OnlineAlgorithm(samples);
else if (algorithm == VarianceAlgorithm.SumsAndSumSquares)
partial_variance_info = M1M2_SumsAndSquares(samples);
else if (algorithm == VarianceAlgorithm.SumsAndSumSquaresWithShift)
partial_variance_info = M1M2_SumsAndSumSquaresWithShift(samples);
else
throw new NotSupportedException($"{algorithm} is not supported");
if (mode == VarianceMode.Biased)
partial_variance_info.M2Denominator = samples.Count;
else
partial_variance_info.M2Denominator = (samples.Count - 1);
return partial_variance_info;
}
private TemplateParametersBuffer(VarianceMode mode, IEnumerable <string> names)
{
this.values = new List <TemplateParameter>();
if (names != null)
{
names.ForEach(s => Add(s, mode));
}
}
public static FunctionBuilder Create(
string name,
string nameParameter,
VarianceMode variance,
INameReference result,
Block body)
{
return(Create(name, TemplateParametersBuffer.Create(variance, nameParameter).Values, result, body));
}
public TemplateParametersBuffer Add(string name, VarianceMode mode = VarianceMode.None)
{
if (this.closed)
{
throw new InvalidOperationException();
}
this.values.Add(new TemplateParameter(this.values.Count, name, mode));
return(this);
}
public static bool PositionCollides(this VarianceMode position, VarianceMode paramMode)
{
if (position == VarianceMode.None)
{
return(paramMode != VarianceMode.None);
}
else
{
return(paramMode != VarianceMode.None && position != paramMode);
}
}
public static FunctionBuilder CreateDeclaration(
string name,
string nameParameter,
VarianceMode variance,
ExpressionReadMode callMode,
INameReference result)
{
return(new FunctionBuilder(name, TemplateParametersBuffer.Create(variance, nameParameter).Values,
null, callMode,
result,
(Block)null));
}
public static VarianceMode Flipped(this VarianceMode position, VarianceMode paramMode)
{
switch (paramMode)
{
case VarianceMode.None: return(VarianceMode.None);
case VarianceMode.In: return(position.Inversed());
case VarianceMode.Out: return(position);
default: throw new NotImplementedException();
}
}
public static VarianceMode Inversed(this VarianceMode @this)
{
switch (@this)
{
case VarianceMode.In: return(VarianceMode.Out);
case VarianceMode.Out: return(VarianceMode.In);
case VarianceMode.None: return(VarianceMode.None);
default: throw new InvalidOperationException();
}
}
public static string ToString(VarianceMode @this)
{
switch (@this)
{
case VarianceMode.In: return("in");
case VarianceMode.Out: return("out");
case VarianceMode.None: return("");
default: throw new InvalidOperationException();
}
}
public TemplateParameter(int index,
string name,
VarianceMode variance)
: base()
{
if (name == null)
{
throw new ArgumentNullException();
}
this.Index = index;
this.Name = name;
this.Variance = variance;
}
public override TypeMatch TemplateMatchesTarget(ComputationContext ctx,
IEntityInstance target, VarianceMode variance, TypeMatching matching)
{
IEnumerable <TypeMatch> matches = this.elements.Select(it => it.TemplateMatchesTarget(ctx, target, variance, matching));
if (matches.Any(it => it == TypeMatch.Same))
{
return(TypeMatch.Same);
}
IEnumerable <TypeMatch> substitutions = matches.Where(it => it == TypeMatch.Substitute).OrderBy(it => it.Distance);
if (substitutions.Any())
{
return(substitutions.First());
}
else
{
return(TypeMatch.No);
}
}
public override TypeMatch TemplateMatchesInput(ComputationContext ctx,
EntityInstance input, VarianceMode variance, TypeMatching matching)
{
TypeMatch match = TypeMatch.No;
foreach (IEntityInstance target in this.elements)
{
TypeMatch m = target.TemplateMatchesInput(ctx, input, variance, matching);
if (m.IsMismatch())
{
return(m);
}
else if (match.IsMismatch())
{
match = m;
}
else if (match != m)
{
return(TypeMatch.No);
}
}
return(match);
}
public TypeMatch TemplateMatchesTarget(ComputationContext ctx, IEntityInstance target, VarianceMode variance, TypeMatching matching)
{
return(target.TemplateMatchesInput(ctx, this, variance, matching));
}
public bool ValidateTypeVariance(ComputationContext ctx, IOwnedNode placement, VarianceMode typeNamePosition)
{
// Programming in Scala, 2nd ed, p. 399 (all errors are mine)
TypeDefinition typedef = this.TargetType;
if (typedef.IsTemplateParameter)
{
TemplateParameter param = typedef.TemplateParameter;
TemplateDefinition template = param.EnclosingScope <TemplateDefinition>();
if (placement.EnclosingScopesToRoot().Contains(template))
{
bool covariant_in_immutable = param.Variance == VarianceMode.Out &&
(template.IsFunction() || template.CastType().InstanceOf.MutabilityOfType(ctx) == TypeMutability.ConstAsSource);
// don't report errors for covariant types which are used in immutable template types
if (!covariant_in_immutable &&
typeNamePosition.PositionCollides(param.Variance))
{
return(false);
}
}
}
else
{
for (int i = 0; i < typedef.Name.Parameters.Count; ++i)
{
if (!this.TemplateArguments[i].ValidateTypeVariance(ctx,
placement,
typeNamePosition.Flipped(typedef.Name.Parameters[i].Variance)))
{
return(false);
}
}
}
return(true);
}
public abstract TypeMatch TemplateMatchesInput(ComputationContext ctx, EntityInstance input,
VarianceMode variance, TypeMatching matching);
public bool ValidateTypeVariance(ComputationContext ctx, IOwnedNode placement, VarianceMode typeNamePosition)
{
return(this.EnumerateAll().All(it => it.ValidateTypeVariance(ctx,
placement,
typeNamePosition)));
}
public abstract TypeMatch TemplateMatchesTarget(ComputationContext ctx, IEntityInstance target,
VarianceMode variance, TypeMatching matching);
public static void ValidateTypeNameVariance(this INameReference @this, ComputationContext ctx, VarianceMode typeNamePosition)
{
if ([email protected](ctx, @this, typeNamePosition))
{
ctx.AddError(ErrorCode.VarianceForbiddenPosition, @this);
}
}
public static StdDevInfo Calculate(IReadOnlyList<double> samples, VarianceMode varianceMode)
{
return Calculate(samples, varianceMode, VarianceAlgorithm.Online);
}
/// <summary>
/// Calculates a Variance of a sample (set of numbers).
/// </summary>
/// <remarks>
/// https://en.wikipedia.org/wiki/Variance
/// Variance measures how far the set of numbers are spread out.
/// Variance == 0 indicates that all numbers are identical.
/// Variance is always non-negative.
/// Variance close to 0 indicates that the numbers tend to be very close to the mean (and hence to each other).
/// </remarks>
/// <param name="samples">observable samples</param>
/// <param name="mode">calculation mode (biased or unbiased)</param>
/// <param name="algorithm">algorithm to use for calculations</param>
public static IObservable<VarianceInfo> Calculate(IObservable<double> samples, VarianceMode mode, VarianceAlgorithm algorithm)
{
return Observable.Create<VarianceInfo>(o =>
{
var count = 0;
VarianceInfo m1m2 = new VarianceInfo();
var M2_Observable = (IObservable<VarianceInfo>)null;
if (algorithm == VarianceAlgorithm.Online)
M2_Observable = M1M2_OnlineAlgorithm(samples);
else
throw new NotSupportedException($"{algorithm} is not supported");
M2_Observable.Subscribe(M2 =>
{
count++;
if (mode == VarianceMode.Biased && count <= 0)
{
m1m2 = VarianceInfo.NaN;
o.OnNext(m1m2);
return;
}
else if (mode == VarianceMode.Unbiased && count <= 1)
{
m1m2 = VarianceInfo.NaN;
o.OnNext(m1m2);
return;
}
if (mode == VarianceMode.Biased)
m1m2.M2Denominator = count;
else
m1m2.M2Denominator = (count - 1);
o.OnNext(m1m2);
});
return Disposable.Empty;
});
}
/// <summary>
/// Calculates a Variance of a sample (set of numbers).
/// </summary>
/// <remarks>
/// https://en.wikipedia.org/wiki/Variance
/// Variance measures how far the set of numbers are spread out.
/// Variance == 0 indicates that all numbers are identical.
/// Variance is always non-negative.
/// Variance close to 0 indicates that the numbers tend to be very close to the mean (and hence to each other).
/// </remarks>
/// <param name="samples">observable samples</param>
/// <param name="mode">calculation mode (biased or unbiased)</param>
public static IObservable<VarianceInfo> Calculate(IObservable<double> samples, VarianceMode mode)
{
var count = 0;
return M1M2_OnlineAlgorithm(samples).Select(M1M2 =>
{
count++;
if (mode == VarianceMode.Biased && count <= 0)
{
return VarianceInfo.NaN;
}
else if (mode == VarianceMode.Unbiased && count <= 1)
{
return VarianceInfo.NaN;
}
if (mode == VarianceMode.Biased)
M1M2.M2Denominator = count;
else
M1M2.M2Denominator = (count - 1);
return M1M2;
});
}
public static NameDefinition Create(string name, string paramName, VarianceMode variance)
{
return(new NameDefinition(name, TemplateParametersBuffer.Create().Add(paramName, variance).Values));
}
public override TypeMatch TemplateMatchesInput(ComputationContext ctx, EntityInstance input, VarianceMode variance,
TypeMatching matching)
{
TypeMatch match = TypeMatch.No;
foreach (IEntityInstance target in this.elements)
{
TypeMatch m = target.TemplateMatchesInput(ctx, input, variance, matching);
if (m == TypeMatch.Same || m == TypeMatch.Substitute)
{
return(m);
}
else if (m == TypeMatch.AutoDereference ||
m == TypeMatch.InConversion ||
m == TypeMatch.ImplicitReference ||
m == TypeMatch.OutConversion)
{
match = m;
}
else if (!m.IsMismatch())
{
throw new NotImplementedException();
}
}
return(match);
}
public static TemplateParametersBuffer Create(VarianceMode mode, params string[] names)
{
return(new TemplateParametersBuffer(mode, names));
}
