public static unsafe TResult SumRange <TResult, TVectorSelector, TSelector>(int start, int count, TVectorSelector vectorSelector, TSelector selector)
where TVectorSelector : struct, IFunction <Vector <int>, Vector <TResult> >
where TSelector : struct, IFunction <int, TResult>
where TResult : struct
{
var sum = default(TResult);
var index = 0;
if (Vector.IsHardwareAccelerated && count > Vector <TResult> .Count * 4) // use SIMD
{
var seed = stackalloc int[Vector <TResult> .Count];
if (start is 0)
{
for (index = 0; index < Vector <TResult> .Count; index++)
{
seed[index] = index;
}
}
else
{
for (index = 0; index < Vector <TResult> .Count; index++)
{
seed[index] = index + start;
}
}
var vector = Unsafe.AsRef <Vector <int> >(seed);
var vectorIncrement = new Vector <int>(Vector <TResult> .Count);
var vectorSum = Vector <TResult> .Zero;
for (index = 0; index <= count - Vector <TResult> .Count; index += Vector <TResult> .Count)
{
vectorSum += vectorSelector.Invoke(vector);
vector += vectorIncrement;
}
for (index = 0; index < Vector <TResult> .Count; index++)
{
sum = GenericsOperator.Add(vectorSum[index], sum);
}
}
if (start is 0)
{
for (; index < count; index++)
{
sum = GenericsOperator.Add(selector.Invoke(index), sum);
}
}
else
{
for (; index < count; index++)
{
sum = GenericsOperator.Add(selector.Invoke(index + start), sum);
}
}
return(sum);
}
static TSum SumNullable <TSource, TSum>(this ReadOnlySpan <TSource> source)
where TSum : struct
{
var sum = default(TSum);
foreach (var item in source)
{
sum = GenericsOperator.Sum(item, sum);
}
return(sum);
}
internal static TSum Sum <TEnumerable, TEnumerator, TSource, TSum>(this TEnumerable source)
where TEnumerable : IValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IEnumerator <TSource>
where TSum : struct
{
var sum = default(TSum);
using var enumerator = source.GetEnumerator();
while (enumerator.MoveNext())
{
sum = GenericsOperator.Sum(enumerator.Current, sum);
}
return(sum);
}
static TSum SumRef <TSource, TSum, TPredicate>(this ReadOnlySpan <TSource> source, TPredicate predicate)
where TPredicate : struct, IFunctionIn <TSource, bool>
where TSum : struct
{
var sum = default(TSum);
foreach (ref readonly var item in source)
{
if (predicate.Invoke(in item))
{
sum = GenericsOperator.Sum(item, sum);
}
}
return(sum);
}
static TSum SumAt <TSource, TSum, TPredicate>(this ReadOnlySpan <TSource> source, TPredicate predicate)
where TPredicate : struct, IFunction <TSource, int, bool>
where TSum : struct
{
var sum = default(TSum);
for (var index = 0; index < source.Length; index++)
{
var item = source[index];
if (predicate.Invoke(item, index))
{
sum = GenericsOperator.Sum(item, sum);
}
}
return(sum);
}
static TSum SumAt <TEnumerable, TEnumerator, TSource, TResult, TSum, TSelector>(this TEnumerable source, TSelector selector)
where TEnumerable : IValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IEnumerator <TSource>
where TSelector : struct, IFunction <TSource, int, TResult>
where TSum : struct
{
var sum = default(TSum);
using var enumerator = source.GetEnumerator();
for (var index = 0; enumerator.MoveNext(); index++)
{
var item = enumerator.Current;
sum = GenericsOperator.Sum(selector.Invoke(item, index), sum);
}
return(sum);
}
static bool ContainsVector <TSource, TResult, TVectorSelector, TSelector>(this ReadOnlySpan <TSource> source, TResult value, TVectorSelector vectorSelector, TSelector selector)
where TVectorSelector : struct, IFunction <Vector <TSource>, Vector <TResult> >
where TSelector : struct, IFunction <TSource, TResult>
where TSource : struct
where TResult : struct
{
if (source.Length is 0)
{
return(false);
}
if (Vector.IsHardwareAccelerated && source.Length > Vector <TSource> .Count * 2)
{
var vectors = MemoryMarshal.Cast <TSource, Vector <TSource> >(source);
var vectorValue = new Vector <TResult>(value);
foreach (var vector in vectors)
{
if (Vector.EqualsAny(vectorSelector.Invoke(vector), vectorValue))
{
return(true);
}
}
for (var index = source.Length - (source.Length % Vector <TSource> .Count); index < source.Length; index++)
{
var item = source[index];
if (GenericsOperator.Equals(selector.Invoke(item), value))
{
return(true);
}
}
}
else
{
foreach (var item in source)
{
if (GenericsOperator.Equals(selector.Invoke(item), value))
{
return(true);
}
}
}
return(false);
}
internal static TSum SumAtRef <TEnumerable, TEnumerator, TSource, TSum, TPredicate>(this TEnumerable source, TPredicate predicate)
where TEnumerable : IValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IEnumerator <TSource>
where TPredicate : struct, IFunctionIn <TSource, int, bool>
where TSum : struct
{
var sum = default(TSum);
using var enumerator = source.GetEnumerator();
for (var index = 0; enumerator.MoveNext(); index++)
{
var item = enumerator.Current;
if (predicate.Invoke(in item, index))
{
sum = GenericsOperator.Sum(item, sum);
}
}
return(sum);
}
public static bool ContainsVector <TSource>(this ReadOnlySpan <TSource> source, TSource value)
where TSource : struct
{
if (source.Length is 0)
{
return(false);
}
if (Vector.IsHardwareAccelerated && source.Length > Vector <TSource> .Count * 2)
{
var vectors = MemoryMarshal.Cast <TSource, Vector <TSource> >(source);
var vectorValue = new Vector <TSource>(value);
foreach (var vector in vectors)
{
if (Vector.EqualsAny(vector, vectorValue))
{
return(true);
}
}
for (var index = source.Length - (source.Length % Vector <TSource> .Count); index < source.Length; index++)
{
var item = source[index];
if (GenericsOperator.Equals(item, value))
{
return(true);
}
}
}
else
{
foreach (var item in source)
{
if (GenericsOperator.Equals(item, value))
{
return(true);
}
}
}
return(false);
}
internal static TSum Sum <TEnumerable, TEnumerator, TSource, TResult, TSum, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector)
where TEnumerable : IValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IEnumerator <TSource>
where TPredicate : struct, IFunction <TSource, bool>
where TSelector : struct, IFunction <TSource, TResult>
where TSum : struct
{
var sum = default(TSum);
using var enumerator = source.GetEnumerator();
while (enumerator.MoveNext())
{
var item = enumerator.Current;
if (predicate.Invoke(item))
{
sum = GenericsOperator.Sum(selector.Invoke(item), sum);
}
}
return(sum);
}
static TResult Sum <TSource, TResult, TVectorSelector, TSelector>(this ReadOnlySpan <TSource> source, TVectorSelector vectorSelector, TSelector selector)
where TVectorSelector : struct, IFunction <Vector <TSource>, Vector <TResult> >
where TSelector : struct, IFunction <TSource, TResult>
where TSource : struct
where TResult : struct
{
var sum = default(TResult);
if (Vector.IsHardwareAccelerated && source.Length > Vector <TResult> .Count * 2) // use SIMD
{
var vectors = MemoryMarshal.Cast <TSource, Vector <TSource> >(source);
var vectorSum = Vector <TResult> .Zero;
foreach (var vector in vectors)
{
vectorSum += vectorSelector.Invoke(vector);
}
for (var index = 0; index < Vector <TResult> .Count; index++)
{
sum = GenericsOperator.Add(vectorSum[index], sum);
}
for (var index = source.Length - (source.Length % Vector <TSource> .Count); index < source.Length; index++)
{
var item = source[index];
sum = GenericsOperator.Add(selector.Invoke(item), sum);
}
}
else
{
foreach (var item in source)
{
sum = GenericsOperator.Add(selector.Invoke(item), sum);
}
}
return(sum);
}
///////////////////////////////////////////////////////////
static TSource Sum <TSource>(this ReadOnlySpan <TSource> source)
where TSource : struct
{
var sum = default(TSource);
if (Vector.IsHardwareAccelerated && source.Length > Vector <TSource> .Count * 2) // use SIMD
{
var vectors = MemoryMarshal.Cast <TSource, Vector <TSource> >(source);
var vectorSum = Vector <TSource> .Zero;
foreach (var vector in vectors)
{
vectorSum += vector;
}
for (var index = 0; index < Vector <TSource> .Count; index++)
{
sum = GenericsOperator.Add(vectorSum[index], sum);
}
for (var index = source.Length - (source.Length % Vector <TSource> .Count); index < source.Length; index++)
{
var item = source[index];
sum = GenericsOperator.Add(item, sum);
}
}
else
{
foreach (var item in source)
{
sum = GenericsOperator.Add(item, sum);
}
}
return(sum);
}
