public async Task ShouldAggregateObjects()
{
// Arrange
var fieldName = nameof(Country).ToLowerCamelCase() + "." + nameof(Country.RegionCode).ToLowerCamelCase();
var request = new ListItemAggregationRequest
{
SearchString = "*",
SchemaIds = new List <string> {
nameof(Country)
},
Aggregators = new List <AggregatorBase>
{
new TermsAggregator {
Name = fieldName, Field = fieldName, Size = 20
}
}
};
// Act
ObjectAggregationResult result = await _client.ListItem.AggregateAsync(request).ConfigureAwait(false);
AggregationResult aggregation = result.GetByName(fieldName);
// Assert
Assert.NotNull(aggregation);
Assert.Equal(20, aggregation.AggregationResultItems.Count);
}
private AggregationResult Modify(TKey key, TElement element)
{
var group = _groups[key];
group.Modify(element);
return(AggregationResult.Modified(group));
}
private IEnumerable <AggregationResult> RunTicketTypesGroupingQuery(IHqlQuery query, AggregateMethods aggregation, string state)
{
var queryResult = CRMHelper.RunGroupByQuery(transactionManager.Value, query, aggregation, "TicketPartRecord.TicketType", state, "ticket");
var ticketTypes = this.basicDataService.GetTicketTypes();
List <AggregationResult> returnValue = new List <AggregationResult>();
foreach (var item in queryResult)
{
var ticketType = item.Key != null?ticketTypes.FirstOrDefault(c => c.Id == item.Key.Value) : null;
string label = ticketType == null?T("[No Ticket Type]").Text : ticketType.Name;
AggregationResult aggregationResult = new AggregationResult
{
AggregationValue = item.Value,
Label = label,
GroupingField = item.Key
};
returnValue.Add(aggregationResult);
}
return(returnValue);
}
private IEnumerable <AggregationResult> Add(TKey key, TElement element)
{
if (Equals(key, _defaultKey))
{
if (_defaultGroup == null)
{
_defaultGroup = new Grouping(key);
_defaultGroup.Add(element);
return(new[] { AggregationResult.Added(_defaultGroup) });
}
_defaultGroup.Add(element);
return(new[] { AggregationResult.Modified(_defaultGroup) });
}
Grouping group;
if (!_groups.TryGetValue(key, out group))
{
group = new Grouping(key);
_groups[key] = group;
group.Add(element);
return(new[] { AggregationResult.Added(group) });
}
group.Add(element);
return(new[] { AggregationResult.Modified(group) });
}
private IEnumerable <AggregationResult> RunTicketPriorityGroupingQuery(IHqlQuery query, AggregateMethods aggregation)
{
var queryResult = this.RunQuery(query, aggregation, "PriorityRecord");
var priorities = this.basicDataService.GetPriorities();
List <AggregationResult> returnValue = new List <AggregationResult>();
foreach (var item in queryResult)
{
var priority = item.Key != null?priorities.FirstOrDefault(c => c.Id == item.Key.Value) : null;
string label = priority == null?T("[No Priority]").Text : priority.Name;
AggregationResult aggregationResult = new AggregationResult
{
AggregationValue = item.Value,
Label = label,
GroupingField = item.Key
};
returnValue.Add(aggregationResult);
}
return(returnValue);
}
private static void AggregateTest(Table table)
{
int iterations = 1000;
AggregationQuery query = new AggregationQuery();
query.Aggregator = new Model.Aggregations.SumAggregator();
query.AggregationColumns = new string[] { "ID" };
query.TableName = "Bugs";
query.Where = SelectQuery.ParseWhere("\"Created Date\" < \"2013-01-01\"");
query.Dimensions.Add(new AggregationDimension("Priority", "Priority < 0", "Priority = 0", "Priority = 1", "Priority > 1"));
query.Dimensions.Add(new AggregationDimension("Framework", "Maui", "Apex", "Tao"));
//query.Dimensions.Add(new AggregationDimension("Created Month",
// "\"Created Date\" >= \"2011-01-01\" AND \"Created Date\" < \"2011-02-01\"",
// "\"Created Date\" >= \"2011-02-01\" AND \"Created Date\" < \"2011-03-01\"",
// "\"Created Date\" >= \"2011-03-01\" AND \"Created Date\" < \"2011-04-01\""
//));
AggregationResult result = null;
Console.WriteLine("\r\n{0}\r\n", query);
Trace.Write("Aggregating Bugs...");
for (int i = 0; i < iterations; ++i)
{
result = table.Query(query);
}
Console.WriteLine();
ShowResult(result.Values);
}
public IEnumerable <AggregationResult> Remove(object fact)
{
var item = (TElement)fact;
_items.Remove(item);
return(new[] { AggregationResult.Modified(_items) });
}
public IEnumerable <AggregationResult> Modify(AggregationContext context, ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var collection = (IEnumerable <TElement>)fact.Value;
foreach (var value in collection)
{
if (_firstElements.TryGetValue(fact, out var oldFirst))
{
if (Equals(oldFirst, value))
{
results.Add(AggregationResult.Modified(value, value, Enumerable.Repeat(fact, 1)));
}
else
{
results.Add(AggregationResult.Removed(oldFirst));
results.Add(AggregationResult.Added(value, Enumerable.Repeat(fact, 1)));
}
}
else
{
results.Add(AggregationResult.Added(value, Enumerable.Repeat(fact, 1)));
}
_firstElements[fact] = value;
break;
}
}
return(results);
}
private IResponse AllCount(IRequestContext ctx, Route route)
{
string queryString = ctx.Request.ResourceParameters["q"] ?? "";
AllCountResult result = new AllCountResult(queryString);
// Build a Count query
IQuery<AggregationResult> query = new AggregationQuery("count", null, queryString);
// Wrap in Joins, if found
query = WrapInJoinQueryIfFound(query, this.Database, ctx);
// Run server correctors
using (ctx.Monitor(MonitorEventLevel.Verbose, "Correct", type: "AllCount", detail: query.Where.ToString()))
{
query.Correct(this.CurrentCorrectors(ctx));
}
// Accumulate Results for each table
IPrincipal user = ctx.Request.User;
using (ctx.Monitor(MonitorEventLevel.Information, "AllCount", type: "AllCount", detail: query.Where.ToString()))
{
IExpression defaultWhere = query.Where;
foreach (string tableName in this.Database.TableNames)
{
if (this.HasTableAccess(tableName, user, PermissionScope.Reader))
{
query.TableName = tableName;
query.Where = defaultWhere;
AggregationResult tableCount = this.Database.Query(query, (si) => this.IsInIdentity(ctx.Request.User, si));
if (!tableCount.Details.Succeeded || tableCount.Values == null)
{
result.ResultsPerTable.Add(new CountResult(tableName, 0, true, false));
}
else
{
result.ResultsPerTable.Add(new CountResult(tableName, (ulong)tableCount.Values[0, 0], true, tableCount.Details.Succeeded));
}
}
else
{
result.ResultsPerTable.Add(new CountResult(tableName, 0, false, false));
}
}
}
// Sort results so that succeeding tables are first and are subsorted by count [descending]
result.ResultsPerTable.Sort((left, right) =>
{
int order = right.Succeeded.CompareTo(left.Succeeded);
if (order != 0) return order;
return right.Count.CompareTo(left.Count);
});
return ArribaResponse.Ok(result);
}
public IEnumerable <AggregationResult> Remove(object fact)
{
var source = (TSource)fact;
var oldValue = _sourceToValue[source];
_sourceToValue.Remove(source);
return(new[] { AggregationResult.Removed(oldValue) });
}
public IEnumerable <AggregationResult> Add(object fact)
{
var source = (TSource)fact;
var value = _selector(source);
_sourceToValue[source] = value;
return(new[] { AggregationResult.Added(value) });
}
private Fact CreateAggregateFact(AggregationResult result)
{
var fact = new SyntheticFact(result.Aggregate);
fact.Source = new AggregateFactSource(result.Source);
_aggregateFactMap.Add(result.Aggregate, fact);
return(fact);
}
public IEnumerable <AggregationResult> Remove(object fact)
{
var source = (TSource)fact;
var oldList = _sourceToList[source];
_sourceToList.Remove(source);
return(oldList.Select(x => AggregationResult.Removed(x)).ToArray());
}
public IEnumerable <AggregationResult> Add(ITuple tuple, IEnumerable <IFact> facts)
{
AddFacts(facts);
if (!_created)
{
_created = true;
return(new[] { AggregationResult.Added(_items) });
}
return(new[] { AggregationResult.Modified(_items) });
}
public IEnumerable <AggregationResult> Add(object fact)
{
var source = (TSource)fact;
var value = _selector(source);
var list = value.ToList();
_sourceToList[source] = list;
return(list.Select(x => AggregationResult.Added(x)).ToArray());
}
public IEnumerable <AggregationResult> RunNumericAggregation(IHqlQuery query, AggregateMethods aggregateMethod, string fieldName, string partName, int interval)
{
string groupKey = string.Format(CultureInfo.InvariantCulture, "cast( floor(field.Value/{0}) as Double) ", interval.ToString(CultureInfo.InvariantCulture));
string groupValue = string.Empty;
switch (aggregateMethod)
{
case AggregateMethods.Count:
groupValue = "COUNT(*)";
break;
case AggregateMethods.Sum:
groupValue = "SUM(field.Value)";
break;
case AggregateMethods.Average:
groupValue = "AVG(field.Value)";
break;
case AggregateMethods.Minimum:
groupValue = "MAX(field.Value)";
break;
case AggregateMethods.Maximum:
groupValue = "MIN(field.Value)";
break;
default:
throw new ArgumentException("Aggregate method is not provided");
}
var result = this.RunQuery(query, fieldName, partName, groupKey, groupValue, "DecimalFieldIndexRecords");
List <AggregationResult> returnValue = new List <AggregationResult>();
foreach (var group in result)
{
double value = double.Parse(group["GroupValue"].ToString());
int? key = group["GroupKey"] != null ? (int?)int.Parse(group["GroupKey"].ToString()) : null;
string keyLabel = !key.HasValue ? T("[{0}]", "Null").Text : T("{0} between {1}-{2}", fieldName, (key.Value * interval).ToString(CultureInfo.InvariantCulture), ((key.Value + 1) * interval).ToString(CultureInfo.InvariantCulture)).Text;
AggregationResult aggregationResult = new AggregationResult
{
AggregationValue = value,
Label = keyLabel,
GroupingField = key
};
returnValue.Add(aggregationResult);
}
return(returnValue);
}
/// <summary>
/// This method determines if the current data sources within the collection can
/// be successfully joined.
/// </summary>
/// <returns>
/// A value of Success is returned if the data sources can be joined.
/// </returns>
/// <remarks>
/// Revision History
/// MM/DD/YY Who Version Issue# Description
/// -------- --- ------- ------------- -----------------------------------
/// 08/26/08 MAH 9.50 Created
/// 12/22/08 MAH 9.50.28 CQ 124459 Added check for number of channels
/// </remarks>
public AggregationResult Validate()
{
AggregationResult ValidationResult = ValidateDeviceID();
if (ValidationResult == AggregationResult.Success)
{
if (m_lstDataSources.Count == 0)
{
ValidationResult = AggregationResult.NoContributors;
}
}
if (ValidationResult == AggregationResult.Success)
{
if (NumProfileChannels == 0)
{
ValidationResult = AggregationResult.NoContributors;
}
}
if (ValidationResult == AggregationResult.Success)
{
if (IntervalLength == 0)
{
ValidationResult = AggregationResult.IntervalLengthMismatch;
}
}
if (ValidationResult == AggregationResult.Success)
{
if (!VerifyDSTConsistency())
{
ValidationResult = AggregationResult.DSTMismatch;
}
}
if (ValidationResult == AggregationResult.Success)
{
if (!VerifyChannelCount())
{
ValidationResult = AggregationResult.ChannelMismatch;
}
}
if (ValidationResult == AggregationResult.Success)
{
if (!VerifyChannelConsistency())
{
ValidationResult = AggregationResult.QuantityMismatch;
}
}
return(ValidationResult);
}
public IEnumerable <AggregationResult> Remove(ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var oldValue = _sourceToValue[fact];
_sourceToValue.Remove(fact);
results.Add(AggregationResult.Removed(oldValue));
}
return(results);
}
public IEnumerable <AggregationResult> Modify(object fact)
{
var source = (TSource)fact;
var value = _selector(source);
var list = value.ToList();
var oldList = _sourceToList[source];
_sourceToList[source] = list;
return(oldList.Select(x => AggregationResult.Removed(x)).Concat(
list.Select(x => AggregationResult.Added(x))).ToArray());
}
private AggregationResult Remove(TKey key, TElement element)
{
var group = _groups[key];
group.Remove(element);
if (group.Count == 0)
{
_groups.Remove(key);
return(AggregationResult.Removed(group));
}
return(AggregationResult.Modified(group));
}
public IEnumerable <AggregationResult> Add(ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var value = _selector.Invoke(tuple, fact);
_sourceToValue[fact] = value;
results.Add(AggregationResult.Added(value));
}
return(results);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var result = new AggregationResult();
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
var name = reader.Value as string;
reader.Read();
switch (name)
{
case "doc_count_error_upper_bound":
result.DocumentCountErrorUpperBound = serializer.Deserialize <long>(reader);
break;
case "sum_other_doc_count":
result.SumOtherDocumentCount = serializer.Deserialize <long>(reader);
break;
case "buckets":
if (reader.TokenType == JsonToken.StartArray)
{
var aggs = new List <AggregationBucket>();
while (reader.Read() && reader.TokenType != JsonToken.EndArray)
{
aggs.Add(serializer.Deserialize <AggregationBucket>(reader));
}
result.Buckets = aggs;
}
break;
default:
if (reader.TokenType == JsonToken.StartObject)
{
var agg = serializer.Deserialize <AggregationResult>(reader);
result.AddAggregation(name, agg);
}
break;
}
break;
case JsonToken.EndObject:
return(result);
default:
break;
}
}
return(result);
}
public void TestApplyAndFilterAggregations()
{
/**
* 127.0.0.1:6379> FT.CREATE test_index SCHEMA name TEXT SORTABLE subj1 NUMERIC SORTABLE subj2 NUMERIC SORTABLE
* OK
* 127.0.0.1:6379> FT.ADD test_index data1 1.0 FIELDS name abc subj1 20 subj2 70
* OK
* 127.0.0.1:6379> FT.ADD test_index data2 1.0 FIELDS name def subj1 60 subj2 40
* OK
* 127.0.0.1:6379> FT.ADD test_index data3 1.0 FIELDS name ghi subj1 50 subj2 80
* OK
* 127.0.0.1:6379> FT.ADD test_index data1 1.0 FIELDS name abc subj1 30 subj2 20
* OK
* 127.0.0.1:6379> FT.ADD test_index data2 1.0 FIELDS name def subj1 65 subj2 45
* OK
* 127.0.0.1:6379> FT.ADD test_index data3 1.0 FIELDS name ghi subj1 70 subj2 70
* OK
*/
Client cl = GetClient();
Schema sc = new Schema();
sc.AddSortableTextField("name", 1.0);
sc.AddSortableNumericField("subj1");
sc.AddSortableNumericField("subj2");
cl.CreateIndex(sc, new ConfiguredIndexOptions());
cl.AddDocument(new Document("data1").Set("name", "abc").Set("subj1", 20).Set("subj2", 70));
cl.AddDocument(new Document("data2").Set("name", "def").Set("subj1", 60).Set("subj2", 40));
cl.AddDocument(new Document("data3").Set("name", "ghi").Set("subj1", 50).Set("subj2", 80));
cl.AddDocument(new Document("data4").Set("name", "abc").Set("subj1", 30).Set("subj2", 20));
cl.AddDocument(new Document("data5").Set("name", "def").Set("subj1", 65).Set("subj2", 45));
cl.AddDocument(new Document("data6").Set("name", "ghi").Set("subj1", 70).Set("subj2", 70));
AggregationBuilder r = new AggregationBuilder().Apply("(@subj1+@subj2)/2", "attemptavg")
.GroupBy("@name", Reducers.Avg("@attemptavg").As("avgscore"))
.Filter("@avgscore>=50")
.SortBy(10, SortedField.Ascending("@name"));
// actual search
AggregationResult res = cl.Aggregate(r);
Row?r1 = res.GetRow(0);
Assert.NotNull(r1);
Assert.Equal("def", r1.Value.GetString("name"));
Assert.Equal(52.5, r1.Value.GetDouble("avgscore"));
Row?r2 = res.GetRow(1);
Assert.NotNull(r2);
Assert.Equal("ghi", r2.Value.GetString("name"));
Assert.Equal(67.5, r2.Value.GetDouble("avgscore"));
}
public IEnumerable <AggregationResult> Modify(AggregationContext context, ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var value = _selector.Invoke(context, tuple, fact);
var oldValue = (TResult)_sourceToValue[fact];
_sourceToValue[fact] = value;
results.Add(AggregationResult.Modified(value, oldValue, Enumerable.Repeat(fact, 1)));
}
return(results);
}
private IEnumerable <AggregationResult> Modify(TKey key, TElement element)
{
if (Equals(key, _defaultKey))
{
_defaultGroup.Modify(element);
return(new[] { AggregationResult.Modified(_defaultGroup) });
}
var group = _groups[key];
group.Modify(element);
return(new[] { AggregationResult.Modified(group) });
}
private Fact RemoveAggregateFact(AggregationResult result)
{
if (!_aggregateFactMap.TryGetValue(result.Aggregate, out var fact))
{
throw new InvalidOperationException(
$"Fact for aggregate object does not exist. AggregatorType={_aggregator.GetType()}, FactType={result.Aggregate.GetType()}");
}
_aggregateFactMap.Remove(fact.RawObject);
fact.RawObject = result.Aggregate;
fact.Source = null;
return(fact);
}
public void Average()
{
var counterData = new MetricsBag();
const double expectedAverage = 3.33;
counterData.Add(-5);
counterData.Add(5);
counterData.Add(10);
AggregationResult agg = counterData.CalculateAggregation();
Assert.AreEqual(expectedAverage, Math.Round(agg.Average, 2));
}
public IEnumerable <AggregationResult> Remove(IEnumerable <object> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var source = (TSource)fact;
var oldValue = _sourceToValue[source];
_sourceToValue.Remove(source);
results.Add(AggregationResult.Removed(oldValue));
}
return(results);
}
public IEnumerable <AggregationResult> Add(IEnumerable <object> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var source = (TSource)fact;
var value = _selector(source);
_sourceToValue[source] = value;
results.Add(AggregationResult.Added(value));
}
return(results);
}
public IEnumerable <AggregationResult> Modify(IEnumerable <object> facts)
{
var keys = new List <TKey>();
var resultLookup = new DefaultKeyMap <TKey, AggregationResult>();
foreach (var fact in facts)
{
var source = (TSource)fact;
var key = _keySelector(source);
var element = _elementSelector(source);
var oldKey = _sourceToKey[fact];
var oldElement = _sourceToElement[fact];
_sourceToKey[fact] = key;
_sourceToElement[fact] = element;
if (Equals(key, oldKey))
{
var result = Modify(key, element);
if (!resultLookup.ContainsKey(key))
{
keys.Add(key);
resultLookup[key] = result;
}
}
else
{
var result1 = Remove(oldKey, oldElement);
if (!resultLookup.ContainsKey(oldKey))
{
keys.Add(oldKey);
}
resultLookup[oldKey] = result1;
var result2 = Add(key, element);
AggregationResult previousResult;
if (!resultLookup.TryGetValue(key, out previousResult))
{
keys.Add(key);
resultLookup[key] = result2;
}
else if (previousResult.Action == AggregationAction.Removed ||
result2.Action == AggregationAction.Added)
{
resultLookup[key] = AggregationResult.Modified(previousResult.Aggregate);
}
}
}
var results = GetResults(keys, resultLookup);
return(results);
}
/// <summary>
/// Aggregates all actions defined for a controller.
/// </summary>
/// <param name="seed">The object that contains the Action definitions.</param>
/// <param name="ignoreCachable">If set to <see langword="true"/>, all actions will be treated equally. The result will then contain the same lists for cachable and uncachable.</param>
/// <returns></returns>
public static AggregationResult Aggregate( IControllerTemplate seed, bool ignoreCachable = false )
{
StringBuilder actions = new StringBuilder();
StringBuilder uncachableActions = new StringBuilder();
// If ignoreCachable is set, we'll aggregate them all into "actions"
foreach( Action action in seed.Actions ) {
if( action.Uncachable && !ignoreCachable ) {
uncachableActions.Append( action.Name + "," );
} else {
actions.Append( action.Name + "," );
}
}
string actionsCachable = actions.ToString();
actionsCachable = ( actionsCachable.Length > 0 )
? actionsCachable.Substring( 0, actionsCachable.Length - 1 )
: actionsCachable;
string actionsUncachable = uncachableActions.ToString();
actionsUncachable = ( actionsUncachable.Length > 0 )
? actionsUncachable.Substring( 0, actionsUncachable.Length - 1 )
: actionsUncachable;
var controllerData =
new {controllerName = NameHelper.UpperCamelCase( seed.Name ), actionList = actionsCachable };
var uncachableControllerData =
new {controllerName = NameHelper.UpperCamelCase( seed.Name ), actionList = actionsUncachable };
AggregationResult result = new AggregationResult {
Cachable = ActionTemplate.FormatSmart( controllerData ),
Uncachable = ActionTemplate.FormatSmart( uncachableControllerData )
};
if( ignoreCachable ) {
result.Uncachable = result.Cachable;
}
return result;
}
private static AggregationResult RunAggregation(ClusterNetwork net, double bias)
{
Dictionary<Vertex, double> _attributes = new Dictionary<Vertex, double>();
Dictionary<Vertex, double> _aggregates = new Dictionary<Vertex, double>();
MathNet.Numerics.Distributions.Normal normal = new MathNet.Numerics.Distributions.Normal(0d, 5d);
AggregationResult result = new AggregationResult();
result.Modularity = net.NewmanModularityUndirected;
double average = 0d;
foreach (Vertex v in net.Vertices)
{
_attributes[v] = normal.Sample();
_aggregates[v] = _attributes[v];
average += _attributes[v];
}
average /= (double)net.VertexCount;
double avgEstimate = double.MaxValue;
result.FinalVariance = double.MaxValue;
result.FinalOffset = 0d;
for (int k = 0; k < Properties.Settings.Default.ConsensusRounds; k++)
{
foreach (Vertex v in net.Vertices.ToArray())
{
Vertex w = v.RandomNeighbor;
List<Vertex> intraNeighbors = new List<Vertex>();
List<Vertex> interNeighbors = new List<Vertex>();
ClassifyNeighbors(net, v, intraNeighbors, interNeighbors);
double r = net.NextRandomDouble();
if (r <= bias && interNeighbors.Count > 0)
w = interNeighbors.ElementAt(net.NextRandom(interNeighbors.Count));
_aggregates[v] = aggregate(_aggregates[v], _aggregates[w]);
_aggregates[w] = aggregate(_aggregates[v], _aggregates[w]);
}
avgEstimate = 0d;
foreach (Vertex v in net.Vertices.ToArray())
avgEstimate += _aggregates[v];
avgEstimate /= (double)net.VertexCount;
result.FinalVariance = 0d;
foreach (Vertex v in net.Vertices.ToArray())
result.FinalVariance += Math.Pow(_aggregates[v] - avgEstimate, 2d);
result.FinalVariance /= (double)net.VertexCount;
double intraVar = 0d;
foreach (int c in net.ClusterIDs)
{
double localavg = 0d;
double localvar = 0d;
foreach (Vertex v in net.GetNodesInCluster(c))
localavg += _aggregates[v];
localavg /= net.GetClusterSize(c);
foreach (Vertex v in net.GetNodesInCluster(c))
localvar += Math.Pow(_aggregates[v] - localavg, 2d);
localvar /= net.GetClusterSize(c);
intraVar += localvar;
}
intraVar /= 50d;
//Console.WriteLine("i = {0:0000}, Avg = {1:0.000}, Estimate = {2:0.000}, Intra-Var = {3:0.000}, Total Var = {4:0.000}", result.iterations, average, avgEstimate, intraVar, totalVar);
}
result.FinalOffset = average - avgEstimate;
return result;
}
