public bool AddBatch <K>(double scalar, IReadOnlyOrderedMap <K, double> batch, out IReadOnlyOrderedMap <K, double> value)
{
var sm = batch as SortedMap <K, double>;
if (!ReferenceEquals(sm, null))
{
double[] newValues = OptimizationSettings.ArrayPool.Take <double>(sm.size);
double[] buffer = new double[Vector <double> .Count];
for (int c = 0; c < Vector <double> .Count; c++)
{
buffer[c] = scalar;
}
var tempVector = new System.Numerics.Vector <double>(buffer);
int i;
for (i = 0; i < newValues.Length; i = i + Vector <double> .Count)
{
var vec = new Vector <double>(sm.values, i);
vec = Vector.Add(vec, tempVector);
vec.CopyTo(newValues, i);
}
for (; i < newValues.Length; i++)
{
newValues[i] = sm.values[i] + scalar;
}
var newKeys = sm.keys.ToArray();
var newSm = SortedMap <K, double> .OfSortedKeysAndValues(newKeys, newValues, sm.size, sm.Comparer, false, sm.IsRegular);
value = newSm;
return(true);
}
throw new NotImplementedException();
}
public IReadOnlyOrderedMap<DateTime, double> MultiplyMap(IReadOnlyOrderedMap<DateTime, double> batch) {
var sm = new SortedMap<DateTime, double>();
foreach (var kvp in batch) {
sm.Add(kvp.Key, kvp.Value * 10.0);
}
return sm;
}
/// <summary>
/// Very straighforward batch operation for testing
/// </summary>
public IReadOnlyOrderedMap<DateTime, double> IncrementMap(IReadOnlyOrderedMap<DateTime, double> batch) {
var sm = new SortedMap<DateTime, double>();
foreach (var kvp in batch) {
sm.Add(kvp.Key, kvp.Value + 1.0);
}
return sm;
}
public bool AddBatch <K>(double scalar, IReadOnlyOrderedMap <K, double> batch, out IReadOnlyOrderedMap <K, double> value)
{
var sm = batch as SortedMap <K, double>;
if (!ReferenceEquals(sm, null))
{
double[] newValues = new double[sm.size];
Yeppp.Core.Add_V64fS64f_V64f(sm.values, 0, scalar, newValues, 0, sm.size);
//Yeppp.Math.Log_V64f_V64f(sm.values, 0, newValues, 0, sm.size);
K[] newKeys;
if (!sm.IsReadOnly)
{
newKeys = sm.keys.ToArray();
}
else
{
OptimizationSettings.ArrayPool.Borrow(sm.keys);
newKeys = sm.keys;
}
var newSm = SortedMap <K, double> .OfSortedKeysAndValues(newKeys, newValues, sm.size, sm.Comparer, false, sm.IsRegular);
value = newSm;
return(true);
}
throw new NotImplementedException();
}
//[Test]
//public void CouldAddWithSimdMathProvider() {
// var sm = new SortedChunkedMap<DateTime, double>();
// var count = 1000;
// for (int i = 0; i < count; i++) {
// sm.Add(DateTime.UtcNow.Date.AddSeconds(i), i);
// }
// var sw = new Stopwatch();
// sw.Start();
// var sum = 0.0;
// for (int rounds = 0; rounds < 10000; rounds++) {
// var bmvc = new BatchMapValuesCursor<DateTime, double, double>(sm.GetCursor,
// (v) => v + 3.1415926, SimdMathProviderSample); //
// while (bmvc.MoveNext()) {
// sum += bmvc.CurrentValue;
// }
// }
// sw.Stop();
// Console.WriteLine("Elapsed msec: {0}", sw.ElapsedMilliseconds);
// Console.WriteLine("Ops: {0}", Math.Round(0.000001 * count * 10000 * 1000.0 / (sw.ElapsedMilliseconds * 1.0), 2));
// Console.WriteLine(sum);
// var c = 0;
// //foreach (var kvp in sm2)
// //{
// // Assert.AreEqual(c + 1, kvp.Value);
// // c++;
// //}
//}
public IReadOnlyOrderedMap <DateTime, double> MathProviderSample(IReadOnlyOrderedMap <DateTime, double> batch)
{
var mathProviderImpl = new MathProviderImpl() as IVectorMathProvider;
IReadOnlyOrderedMap <DateTime, double> sm2;
var ok = mathProviderImpl.AddBatch(3.1415926, batch, out sm2);
return(sm2);
}
public IReadOnlyOrderedMap <DateTime, double> YeppMathProviderSample(IReadOnlyOrderedMap <DateTime, double> batch)
{
var mathProviderImpl = new Spreads.NativeMath.YepppMathProvider();
IReadOnlyOrderedMap <DateTime, double> sm2;
var ok = mathProviderImpl.AddBatch(3.1415926, batch, out sm2);
return(sm2);
}
public IReadOnlyOrderedMap <DateTime, double> MultiplyMap(IReadOnlyOrderedMap <DateTime, double> batch)
{
var sm = new SortedMap <DateTime, double>();
foreach (var kvp in batch)
{
sm.Add(kvp.Key, kvp.Value * 10.0);
}
return(sm);
}
/// <summary>
/// Very straighforward batch operation for testing
/// </summary>
public IReadOnlyOrderedMap <DateTime, double> IncrementMap(IReadOnlyOrderedMap <DateTime, double> batch)
{
var sm = new SortedMap <DateTime, double>();
foreach (var kvp in batch)
{
sm.Add(kvp.Key, kvp.Value + 1.0);
}
return(sm);
}
public bool SumBatch <K>(double scalar, IReadOnlyOrderedMap <K, double> batch, out double value)
{
var sm = batch as SortedMap <K, double>;
if (!ReferenceEquals(sm, null))
{
double[] newValues = new double[sm.size];
//Yeppp.Core.Add_V64fS64f_V64f(sm.values, 0, scalar, newValues, 0, sm.size);
value = Yeppp.Core.Sum_V64f_S64f(sm.values, 0, sm.size);
return(true);
}
throw new NotImplementedException();
}
public ContractsTests(IReadOnlyOrderedMap <K, V> testSeries,
SortedMap <K, V> materializedSeries,
SortedMap <K, V> ephemeralSeries = null)
{
if (testSeries == null)
{
throw new ArgumentNullException(nameof(testSeries));
}
if (materializedSeries == null)
{
throw new ArgumentNullException(nameof(materializedSeries));
}
_testSeries = testSeries;
_materializedSeries = materializedSeries;
_ephemeralSeries = ephemeralSeries;
if (ephemeralSeries != null)
{
var eqc = EqualityComparer <V> .Default;
// TODO (UX) Spreads signature conflicts with LINQ, easy to fix but not very convenient
var intersect = materializedSeries.Zip(ephemeralSeries, (l, r) => {
if (!eqc.Equals(l, r))
{
throw new ArgumentException("materializedSeries and ephemeralSeries contain different values for the same keys");
}
else
{
return(l);
}
});
if (intersect.IsEmpty)
{
foreach (var kvp in materializedSeries.Take(10))
{
ephemeralSeries[kvp.Key] = kvp.Value;
}
}
}
}
public int Append(IReadOnlyOrderedMap <K, Vdest> appendMap, AppendOption option)
{
var count = _innerMap.Append(appendMap.Map(_destToSrc), option);
return(count);
}
public int Append(IReadOnlyOrderedMap <K, SortedMap <K, V> > appendMap, AppendOption option)
{
throw new NotImplementedException();
}
public bool MapBatch <K, V, V2>(FSharpFunc <V, V2> mapF, IReadOnlyOrderedMap <K, V> batch, out IReadOnlyOrderedMap <K, V2> value)
{
throw new NotImplementedException();
}
public bool AddBatch <K>(IReadOnlyOrderedMap <K, double> left, IReadOnlyOrderedMap <K, double> right, out IReadOnlyOrderedMap <K, double> value)
{
throw new NotImplementedException();
}
public OMEnumerator(IReadOnlyOrderedMap <TKey, TValue> source)
{
Source = source;
}
public IReadOnlyOrderedMap<DateTime, double> YeppMathProviderSample(IReadOnlyOrderedMap<DateTime, double> batch) {
var mathProviderImpl = new Spreads.NativeMath.YepppMathProvider();
IReadOnlyOrderedMap<DateTime, double> sm2;
var ok = mathProviderImpl.AddBatch(3.1415926, batch, out sm2);
return sm2;
}
public IReadOnlyOrderedMap<DateTime, double> MathProviderSample(IReadOnlyOrderedMap<DateTime, double> batch)
{
var mathProviderImpl = new MathProviderImpl() as IVectorMathProvider;
IReadOnlyOrderedMap<DateTime, double> sm2;
var ok = mathProviderImpl.AddBatch(3.1415926, batch, out sm2);
return sm2;
}
