private static void CacheMethodCall(object oParameters)
{
CacheMethodCallParams parameters = (CacheMethodCallParams)oParameters;
try {
Monitor.Enter(DynamicLock.Get(CACHING_LOCK_TYPE, parameters.CachingKey));
parameters.Method._mi.Invoke(null, (new object[] { parameters.Request, parameters.Reply.Result, parameters.Reply.Error }));
if (!parameters.Reply.Error.Exists)
{
ResultCache.CacheResult(
parameters.Method.Id,
parameters.ResultKey,
parameters.Request.ParameterSet.ToXml().ToXElement(),
parameters.Reply.Result.Raw.ToXElement()
);
}
}
catch (Exception e) {
Manager.LogFault(parameters.Request, parameters.Reply, parameters.Method, "AsynchronousInvocationException", e);
}
finally {
lock (DynamicLock.Lock) {
Monitor.Exit(DynamicLock.Get(CACHING_LOCK_TYPE, parameters.CachingKey));
DynamicLock.Remove(CACHING_LOCK_TYPE, parameters.CachingKey);
}
}
}
private void RemoveFromCache(bool localOnly, string id)
{
if (String.IsNullOrEmpty(id))
{
throw new ArgumentException("The key cannot be null or empty", "id");
}
ResultCache.Remove(id, localOnly);
if (!localOnly)
{
Task.Run(() =>
{
InterNodeCommunicationMessage msg = new InterNodeCommunicationMessage {
Tag = id, IsLocalOnly = true, MessageType = InterNodeMessageType.RemoveFromCache
};
// not sure this is valid as its non deterministic
lock (KnownNodes)
{
foreach (var el in KnownNodes)
{
SendToNode(el, InterNodeCommunicationMessageSerialiser.Serialise(msg));
}
}
});
}
}
private ServiceCallSite TryCreateExact(ServiceDescriptor descriptor, Type serviceType, CallSiteChain callSiteChain, int slot)
{
if (serviceType == descriptor.ServiceType)
{
ServiceCallSite callSite;
var lifetime = new ResultCache(descriptor.Lifetime, serviceType, slot);
if (descriptor.ImplementationInstance != null)
{
callSite = new ConstantCallSite(descriptor.ServiceType, descriptor.ImplementationInstance);
}
else if (descriptor.ImplementationFactory != null)
{
callSite = new FactoryCallSite(lifetime, descriptor.ServiceType, descriptor.ImplementationFactory);
}
else if (descriptor.ImplementationType != null)
{
callSite = CreateConstructorCallSite(lifetime, descriptor.ServiceType, descriptor.ImplementationType, callSiteChain);
}
else
{
throw new InvalidOperationException("Invalid service descriptor");
}
return(callSite);
}
return(null);
}
/// ------------------------------------------------------------------------------------
public bool Search(bool returnCountOnly, out int resultCount)
{
ResultCache = (returnCountOnly ? null : new WordListCache());
resultCount = 0;
foreach (var wentry in _project.WordCache)
{
if (ReportProgressAction != null)
{
ReportProgressAction();
}
// Get a list of word(s) for this entry. If the query's IncludeAllUncertainPossibilities
// flag is set, there will be multiple words, one for each uncertain possibility.
// Otherwise there will be only one. Each word is delivered in the form of an array of
// phones.
var wordsList = (_query.IncludeAllUncertainPossibilities && wentry.ContiansUncertainties ?
wentry.GetAllPossibleUncertainWords(false) : new[] { wentry.Phones });
foreach (var phonesInWord in wordsList)
{
resultCount = SearchWord(phonesInWord, returnCountOnly,
(phoneIndexOfMatch, numberOfPhonesInMatch) =>
ResultCache.Add(wentry, phonesInWord, phoneIndexOfMatch, numberOfPhonesInMatch, true));
}
}
return(true);
}
public TValue GetValue()
{
var result = new ResultCache();
AsyncGet(result);
return(result.Value);
}
public static void StringResultCreation(string x)
{
var expected = Result.Ok(x);
var cache = new ResultCache(1);
var actual = (Result <string>)cache.RetrieveOrCacheOk(typeof(string), x);
Assert.True(ResultEqual(expected, actual));
}
public static void IntListResultCreation(List <int> x)
{
var expected = Result.Ok(x);
var cache = new ResultCache(1);
var actual = (Result <List <int> >)cache.RetrieveOrCacheOk(typeof(List <int>), x);
Assert.True(ResultEqual(expected, actual));
}
public static void IntListResultErrorCreation(IEnumerable <Error> errors, ResultClass resultClass)
{
var expected = Result.WithErrors <List <int> >(errors, resultClass);
var cache = new ResultCache(1);
var actual = (Result <List <int> >)cache.RetrieveOrCacheWithErrors(typeof(List <int>), errors, resultClass);
Assert.True(ResultEqual(expected, actual));
}
public async Task ResultFailReturnsDefaultObject()
{
var mock = new MockDataRetriever();
var cache = new ResultCache <string>(Key, mock.GetFailData, GetCache());
var result = await cache.Get();
Assert.Null(result);
}
public static void IntResultCreation(int x)
{
var expected = Result.Ok(x);
var cache = new ResultCache(1);
var actual = (Result <int>)cache.RetrieveOrCacheOk(typeof(int), x);
Assert.Equal(expected, actual);
}
public async Task DataIsRetrievedOnceOnFirstTimeUse()
{
var mock = new MockDataRetriever();
var cache = new ResultCache <string>(Key, mock.GetData, GetCache());
var cachedData = await cache.Get();
Assert.Equal(1, mock.DataRetrievalCount);
Assert.Equal("this is the data", cachedData);
}
static public ResultCache Get()
{
if (cache == null)
{
cache = new ResultCache();
}
return(cache);
}
public static HashSet <string> GetFiles(
ResultCache cache,
string searchableDirectory,
IEnumerable <IPattern> includePaths,
IEnumerable <IPattern> excludePaths,
string basePath = null)
{
return(GetFiles(cache, new[] { searchableDirectory }, includePaths, excludePaths, basePath));
}
public IEnumerable <TItem> Read <TItem>()
{
TableIdentity heading = TableIdentity.FromRecord(this.syncReader);
ResultState <TItem> state = ResultCache <TItem> .GetResultState(this.schemas, heading);
while (this.syncReader.Read())
{
yield return(state.Item(this.syncReader));
}
}
public void GetEmptyResultFromCache()
{
ResultCache sut = new ResultCache();
ProcessingResult cachedResultUser1 = sut.Get("testUser1");
sut.Set("testUser3", new ProcessingResult());
ProcessingResult cachedResultUser2 = sut.Get("testUser2");
Assert.Null(cachedResultUser1);
Assert.Null(cachedResultUser2);
}
public void PoisonDisposesTheCache()
{
var mock = new MockDataRetriever();
var cache = new ResultCache <string>(Key, mock.GetData, GetCache());
cache.Get();
Assert.Equal(1, mock.DataRetrievalCount);
cache.Poison();
cache.Get();
Assert.Equal(2, mock.DataRetrievalCount);
}
public async Task WhenCacheIsEmptyItReRetrievesTheData()
{
var mock = new MockDataRetriever();
var underlyingCache = GetCache();
var cache = new ResultCache <string>(Key, mock.GetData, underlyingCache);
underlyingCache.Remove(Key);
var cachedData = await cache.Get();
Assert.Equal(1, mock.DataRetrievalCount);
Assert.Equal("this is the data", cachedData);
}
private ServiceCallSite TryCreateOpenGeneric(ServiceDescriptor descriptor, Type serviceType, CallSiteChain callSiteChain, int slot)
{
if (serviceType.IsConstructedGenericType &&
serviceType.GetGenericTypeDefinition() == descriptor.ServiceType)
{
Debug.Assert(descriptor.ImplementationType != null, "descriptor.ImplementationType != null");
var lifetime = new ResultCache(descriptor.Lifetime, serviceType, slot);
var closedType = descriptor.ImplementationType.MakeGenericType(serviceType.GenericTypeArguments);
return(CreateConstructorCallSite(lifetime, serviceType, closedType, callSiteChain));
}
return(null);
}
public void GetResultFromCacheAfterInitialAdd()
{
ResultCache sut = new ResultCache();
ProcessingResult resultUser1 = new ProcessingResult();
ProcessingResult resultUser2 = new ProcessingResult();
sut.Set("testUser1", resultUser1);
sut.Set("testUser2", resultUser2);
ProcessingResult cachedResultUser1 = sut.Get("testUser1");
ProcessingResult cachedResultUser2 = sut.Get("testUser2");
Assert.Equal(resultUser1, cachedResultUser1);
Assert.Equal(resultUser2, cachedResultUser2);
}
public async IAsyncEnumerable <TItem> ReadAsync <TItem>([EnumeratorCancellation] CancellationToken cancellationToken = default)
{
if (this.asyncReader == null)
{
throw new QueryException("Async not available. To use async operations, please supply a connection factory returning a DbConnection instance.");
}
TableIdentity heading = TableIdentity.FromRecord(this.asyncReader);
ResultState <TItem> state = ResultCache <TItem> .GetResultState(this.schemas, heading);
while (await this.asyncReader.ReadAsync(cancellationToken).ConfigureAwait(false))
{
yield return(state.Item(this.asyncReader));
}
}
private void GetResultFromCache(IPAddress source, string tag)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (String.IsNullOrEmpty(tag))
{
throw new ArgumentNullException("tag");
}
if (ResultCache.Contains(tag))
{
SendToNode(source, ClientResultMessageSerialiser.Serialise(ResultCache[tag]));
}
}
public async Task CachedDataIsRetrievedOnSubsequentUse()
{
var mock = new MockDataRetriever();
var cache = new ResultCache <string>(Key, mock.GetData, GetCache());
var result1 = await cache.Get();
var result2 = await cache.Get();
var result3 = await cache.Get();
var result4 = await cache.Get();
var result5 = await cache.Get();
Assert.Equal(1, mock.DataRetrievalCount);
Assert.True(new[] { result1, result2, result3, result4, result5 }.All(o => o.Equals("this is the data")));
}
public void GetResultFromCacheAfterRewrite()
{
ResultCache sut = new ResultCache();
ProcessingResult result1 = new ProcessingResult();
sut.Set("testUser", result1);
ProcessingResult cachedResult1 = sut.Get("testUser");
Assert.Equal(result1, cachedResult1);
ProcessingResult Result = new ProcessingResult();
sut.Set("testUser", Result);
ProcessingResult cachedResult2 = sut.Get("testUser");
Assert.Equal(Result, cachedResult2);
}
public static bool Create <T>(T albianObject)
where T : class, IAlbianObject
{
if (null == albianObject)
{
throw new ArgumentNullException("albianObject");
}
TaskBuilder builder = new TaskBuilder();
ITask task = builder.BuildCreateTask(albianObject);
ITransactionClusterScope tran = new TransactionClusterScope();
bool isSuccess = tran.Execute(task);
if (!isSuccess)
{
return(isSuccess);
}
ResultCache.CachingObject(albianObject);
return(isSuccess);
}
private static IList <T> DoLoadObjects <T>(IDbCommand cmd)
where T : class, IAlbianObject, new()
{
try
{
IQueryCluster query = new QueryCluster();
IList <T> targets = query.QueryObjects <T>(cmd);
ResultCache.CachingObjects(cmd, targets);
return(targets);
}
catch (Exception exc)
{
if (null != Logger)
{
Logger.ErrorFormat("Find Object is error..info:{0}.", exc.Message);
}
throw;
}
}
public async Task SeperateInstancesWithSameKey()
{
var mock = new MockDataRetriever();
var cache = new ResultCache <string>(Key, mock.GetData, GetCache());
var cache2 = new ResultCache <string>(Key, mock.GetData, GetCache());
var result1 = await cache.Get();
var result2 = await cache.Get();
var result3 = await cache.Get();
var result4 = await cache2.Get();
var result5 = await cache2.Get();
var result6 = await cache2.Get();
Assert.Equal(2, mock.DataRetrievalCount); // we expect 2 because the data will be re-retrieved when newing up the second instance
Assert.True(new[] { result1, result2, result3, result4, result5, result6 }.All(o => o.Equals("this is the data")));
}
internal void AddToCache(bool localOnly, string key, byte[] value)
{
// Sanity check everything first.
if (String.IsNullOrEmpty(key))
{
throw new ArgumentException("The key cannot be null", "key");
}
if (value == null || value.Length == 0)
{
throw new ArgumentException("The entry to the cache cannot be null", "value");
}
ClientResultMessage msg = new ClientResultMessage {
Data = value, Key = key
};
// Update
ResultCache.Write(key, msg, localOnly);
}
public async Task <Response> Request(Request request)
{
// Send request
var resultReady = new AutoResetEvent(false);
RequestQueue[request.Id] = resultReady;
await RpcLayer.SendRequest(request);
await Task.Run(() => resultReady.WaitOne());
// Remove lock from queue
AutoResetEvent removedEvent;
RequestQueue.TryRemove(request.Id, out removedEvent);
// Retrieve result
var result = ResultCache[request.Id];
Response dequeuedResponse;
ResultCache.TryRemove(request.Id, out dequeuedResponse);
return(result);
}
private static T DoLoadObject <T>(string routingName, IFilterCondition[] where)
where T : class, IAlbianObject, new()
{
try
{
ITaskBuilder taskBuilder = new TaskBuilder();
ITask task = taskBuilder.BuildQueryTask <T>(routingName, 0, where, null);
IQueryCluster query = new QueryCluster();
T target = query.QueryObject <T>(task);
ResultCache.CachingObject(routingName, where, target);
return(target);
}
catch (Exception exc)
{
if (null != Logger)
{
Logger.ErrorFormat("load Object is error..info:{0}.", exc.Message);
}
throw;
}
}
public async Task WhenCacheIsEmptyItReRetrievesTheDataAndCachesIt()
{
var mock = new MockDataRetriever();
var underlyingCache = GetCache();
var cache = new ResultCache <string>(Key, mock.GetData, underlyingCache);
underlyingCache.Remove(Key);
var result1 = await cache.Get();
var result2 = await cache.Get();
var result3 = await cache.Get();
var result4 = await cache.Get();
var result5 = await cache.Get();
Assert.Equal(1, mock.DataRetrievalCount);
Assert.True(new[] { result1, result2, result3, result4, result5 }.All(o => o.Equals("this is the data")));
}
internal Result Execute
(
Category category,
ResultCache left,
Syntax token,
ContextBase context,
Parser.Value right)
{
var trace = ObjectId.In(34) && category.HasCode;
StartMethodDump(trace, category, left, token, context, right);
try
{
var metaFeature = ((IMetaImplementation) Feature).Function;
if(metaFeature != null)
return metaFeature.Result(category, left, context, right);
BreakExecution();
var result = Feature.Result(category.Typed, token, context, right);
Dump(nameof(result), result);
Dump("ConverterPath.Destination.CheckedReference", ConverterPath.Destination.CheckedReference);
Dump("ConverterPath.Execute", ConverterPath.Execute(Category.Code));
BreakExecution();
var replaceAbsolute = result
.ReplaceAbsolute
(ConverterPath.Destination.CheckedReference, ConverterPath.Execute);
Dump(nameof(replaceAbsolute), replaceAbsolute);
if(trace)
Dump(nameof(left), left.Code);
BreakExecution();
return ReturnMethodDump(replaceAbsolute.ReplaceArg(left));
}
finally
{
EndMethodDump();
}
}
ReplaceRelRefArg(ResultCache actualArg, Size offset)
: base(actualArg)
{
Offset = offset;
StopByObjectIds(-9);
}
/// <summary>
/// Creates equifrequency intervals from the sorted array of values from database.
/// </summary>
/// <param name="intervals">Requested number of intervals.</param>
/// <param name="sortedValues">It is assumed that the values from database are of type double, although any type that converts to double will do. The array must be already sorted though.</param>
/// <returns>An array of dividing points. The first point returned is the right bound of the first value (the left bound can be -INF), the last point returned is the left bound of the last interval (right bound can be INF).</returns>
/// <remarks>
/// <para>This method is an optimization algorithm. It heuristically checks many different
/// combinations of dividing points and computes scoring for every such division.
/// The scoring function is in fact a least square method and the optimization is searching
/// for point of minimum error. See more details in other types of documentation.</para>
/// </remarks>
public static object[] GenerateIntervals(int intervals, object[] sortedValues)
{
if ((sortedValues == null) || (sortedValues.Length == 0))
throw new ArgumentException("The reference to the array of sorted values is null or contains no elements.", "sortedValues");
if (intervals < 1)
throw new ArgumentOutOfRangeException("intervals", intervals, "The number of intervals must be at least 1.");
// create an array list of values and their counts
ArrayList dataArray = new ArrayList();
int i = 0;
object currentValue = null;
while (i < sortedValues.Length)
{
currentValue = sortedValues[i];
i++;
if (currentValue != null)
break;
}
if (currentValue == null)
throw new ArgumentException("The array of values contains only null values.");
int currentCount = 1;
int totalCount = 1;
while (i < sortedValues.Length)
{
if (sortedValues[i] != null)
{
Debug.Assert(((IComparable) currentValue).CompareTo((IComparable) sortedValues[i]) <= 0);
if (currentValue.Equals(sortedValues[i]))
{
currentCount++;
}
else
{
dataArray.Add(new Data(currentValue, currentCount));
currentValue = sortedValues[i];
currentCount = 1;
}
totalCount++;
}
i++;
}
dataArray.Add(new Data(currentValue, currentCount));
// assert that the number of intervals is less than or equal to the total number of different values
if (dataArray.Count < intervals)
throw new ArgumentOutOfRangeException("intervals", intervals, "The requested number of intervals is less than the total number of different values.");
// initialize the cache
ResultCache cache = new ResultCache(intervals);
#if PERFCOUNTERS
recursionCount = 0;
cacheHit = 0;
cacheMiss = 0;
#endif
// start the recursion
Result result = FindSplit(dataArray, new Interval(0, dataArray.Count), intervals, (float) totalCount / (float) intervals, cache);
#if PERFCOUNTERS
Trace.WriteLine("Equifrequency intervals performance:");
Trace.WriteLine(String.Format("total {0}", totalCount));
Trace.WriteLine(String.Format("different values {0}", dataArray.Count));
Trace.WriteLine(String.Format("intervals {0}", intervals));
Trace.WriteLine(String.Format("recursion {0}", recursionCount));
Trace.WriteLine(String.Format("cache hits {0}", cacheHit));
Trace.WriteLine(String.Format("cache misses {0}", cacheMiss));
Trace.WriteLine(String.Format("result error {0}", result.Cost));
Trace.WriteLine(String.Empty);
#endif
// get the split points
object[] resultObjects = new object[intervals - 1];
for (i = 0; i < intervals - 1; i++)
{
resultObjects[i] = ((Data) dataArray[((Interval) result.Intervals[i]).Right]).Value;
}
return resultObjects;
}
private static Result FindSplit(ArrayList dataArray, Interval bounds, int intervals, float optimum, ResultCache cache)
{
#if PERFCOUNTERS
recursionCount++;
#endif
#if SCOREGRAPH
bool topLevel = (bounds.Left == 0) && (bounds.Right == dataArray.Count);
#endif
// check if there is enough split points
Debug.Assert(bounds.Right - bounds.Left >= intervals);
// test the end of recursion (no splitting)
if (intervals == 1)
{
Result result = new Result();
result.Intervals.Add(bounds);
int count = 0;
for (int i = bounds.Left; i < bounds.Right; i++)
count += ((Data) dataArray[i]).Count;
result.Cost = ResultPenalty(count, optimum);
return result;
}
// test the end of recursion (exact splitting, no choice)
if (intervals == bounds.Right - bounds.Left)
{
Result result = new Result();
result.Cost = 0.0f;
for (int i = bounds.Left; i < bounds.Right; i++)
{
result.Intervals.Add(new Interval(i, i + 1));
result.Cost += ResultPenalty(((Data) dataArray[i]).Count, optimum);
}
return result;
}
// cache lookup
{
Result result = cache.GetResult(intervals, bounds);
if (result != null)
return result;
}
// count objects that must be in the left part
int leftIntervals = intervals / 2;
int leftSum = 0;
for (int i = 0; i < leftIntervals; i++)
leftSum += ((Data) dataArray[bounds.Left + i]).Count;
// add some more intervals until optimal point is reached
int bestSplit;
int leftOptimalSum = (int) Math.Round(optimum * leftIntervals);
for (bestSplit = bounds.Left + leftIntervals; bestSplit < bounds.Right - (intervals - leftIntervals); bestSplit++)
{
if (leftSum + ((Data) dataArray[bestSplit]).Count > leftOptimalSum)
break;
leftSum += ((Data) dataArray[bestSplit]).Count;
}
// start testing these split points (spreading to left and right)
int leftSplit = bestSplit;
int rightSplit = bestSplit + 1;
bool leftStop = false; // there's always at least one solution
bool rightStop = (rightSplit > bounds.Right - (intervals - leftIntervals)); // go right only if there is another possible split point
// spread to both sides and search for better solutions
Result bestResult = new Result(), leftTmpResult, rightTmpResult;
bestResult.Cost = initPenalty;
float leftLastScore = initPenalty, rightLastScore = initPenalty;
int leftGrowCount = 0, rightGrowCount = 0;
while (!leftStop || !rightStop)
{
if (!leftStop)
{
// find solution for left and right part
leftTmpResult = FindSplit(dataArray, new Interval(bounds.Left, leftSplit), leftIntervals, optimum, cache);
rightTmpResult = FindSplit(dataArray, new Interval(leftSplit, bounds.Right), intervals - leftIntervals, optimum, cache);
// sum the costs of partial results
float sum = leftTmpResult.Cost + rightTmpResult.Cost;
#if SCOREGRAPH
if (topLevel)
{
// top level in the recursion
Trace.WriteLine(String.Format("{0};{1}", leftSplit, sum));
}
#endif
// first solution is propagated to the right side
if (rightLastScore == initPenalty)
{
// save to right last value
rightLastScore = sum;
}
// compare this result to what we have so far
if (sum < bestResult.Cost)
{
// merge two partial solution to one
bestResult.Merge(leftTmpResult, rightTmpResult);
// absolute stop criterium (perfect result)
if (sum == 0.0f)
break;
}
#if SCOREGRAPH
if (!topLevel)
{
#endif
// check stop criterium (result penalty is too big)
if (sum > stopLimit * bestResult.Cost)
{
// stop spreading to the left
leftStop = true;
}
// check stop criterium (result penalty is constantly growing, so there is
// probably no hope of getting better result than we have...)
if (sum < leftLastScore)
{
// not growing, reset the counter
leftGrowCount = 0;
}
else
{
// growing, increase
leftGrowCount++;
if (leftGrowCount == growLimit)
leftStop = true;
}
leftLastScore = sum;
#if SCOREGRAPH
}
#endif
// check if there is possibility to spread further to the left
if (leftSplit <= bounds.Left + leftIntervals)
{
// stop testing spreading to the left
leftStop = true;
}
else
{
// shift the left split to the next position
leftSplit--;
}
}
if (!rightStop)
{
// find solution for left and right part
leftTmpResult = FindSplit(dataArray, new Interval(bounds.Left, rightSplit), leftIntervals, optimum, cache);
rightTmpResult = FindSplit(dataArray, new Interval(rightSplit, bounds.Right), intervals - leftIntervals, optimum, cache);
// sum the costs of partial results
float sum = leftTmpResult.Cost + rightTmpResult.Cost;
#if SCOREGRAPH
if (topLevel)
{
// top level in the recursion
Trace.WriteLine(String.Format("{0};{1}", rightSplit, sum));
}
#endif
// compare this result to what we have so far
if (sum < bestResult.Cost)
{
// merge two partial solution to one
bestResult.Merge(leftTmpResult, rightTmpResult);
}
#if SCOREGRAPH
if (!topLevel)
{
#endif
// check stop criterium (result penalty is too big)
if (sum > stopLimit * bestResult.Cost)
{
// stop testing spreading to the right
rightStop = true;
}
// check stop criterium (result penalty is constantly growing, so there is
// probably no hope of getting better result than we have...)
if (sum < rightLastScore)
{
// not growing, reset the counter
rightGrowCount = 0;
}
else
{
// growing, increase
rightGrowCount++;
if (rightGrowCount == growLimit)
rightStop = true;
}
rightLastScore = sum;
#if SCOREGRAPH
}
#endif
// check if there is possibility to spread further to the right
if (rightSplit >= bounds.Right - (intervals - leftIntervals))
{
// stop testing spreading to the right
rightStop = true;
}
else
{
// shift the right split to the next position
rightSplit++;
}
}
}
// check the solution
Debug.Assert(bestResult.Cost < initPenalty);
// add the best result to cache
cache.SetResult(intervals, bounds, bestResult);
// ...and return it
return bestResult;
}
/// <summary>
/// Generates the intervals.
/// </summary>
/// <param name="intervals">The count of required intervals.</param>
/// <param name="dataArray">The data array.</param>
/// <returns>Split points.</returns>
public static object[] GenerateIntervals(int intervals, ArrayList dataArray)
{
// assert that the number of intervals is less than or equal to the total number of different values
if (dataArray.Count < intervals)
throw new ArgumentOutOfRangeException("intervals", intervals, "The requested number of intervals is less than the total number of different values.");
// initialize the cache
ResultCache cache = new ResultCache(intervals);
// start the recursion
Result result = FindSplit(dataArray, new Interval(0, dataArray.Count), intervals, (float)dataArray.Count / (float)intervals, cache);
// get the split points
object[] resultObjects = new object[intervals - 1];
for (int i = 0; i < intervals - 1; i++)
{
resultObjects[i] = ((Data)dataArray[((Interval)result.Intervals[i]).Right]).Value;
}
return resultObjects;
}
public ReplaceAbsoluteArg(ResultCache actualArg)
: base(actualArg) { }
Result IMeta.Result
(Category category, ResultCache left, ContextBase contextBase, Value right)
{
NotImplementedMethod(contextBase, left, category, right);
return null;
}
internal ReplaceRelRefArg(ResultCache actualArg)
: this(actualArg, Size.Create(0)) {}
internal ReplaceArg(ResultCache actualArg)
: base(_nextObjectId++)
{
Tracer.Assert(actualArg != null, () => "actualArg != null");
ActualArg = actualArg;
}
