cdrnet
commented
10 years ago Creating a vector view is quite straight forward, but will cause all algorithms to fall back to slow indexer-based algorithms since none of them would understand its storage structure (yet). So as is this will not be interesting if performance is important as well.
Example for doubles:
public class VectorView : Vector
{
public VectorView(double[] data, int offset, int length)
: base(new Storage(data, offset, length))
{
}
class Storage : VectorStorage<double>
{
readonly double[] _data;
readonly int _offset;
public Storage(double[] data, int offset, int length) : base(length)
{
_data = data;
_offset = offset;
}
public override bool IsDense
{
get { return true; }
}
public override double At(int index)
{
return _data[_offset + index];
}
public override void At(int index, double value)
{
_data[_offset + index] = value;
}
}
}Using it e.g. in LINQPad with its Dump functions:
void Main()
{
double[] data = Generate.Gaussian(10, 0.0, 1.0);
var first = new DenseVector(data).Dump("first");
var view1 = new VectorView(data, 2, 2).Dump("v1");
var view2 = new VectorView(data, 6, 2).Dump("v2");
var second = Vector<double>.Build.Random(2).Dump("second");
(view1 + view2).Dump("v1+v2");
(view1 + second).Dump("v1+second");
}I've been experimenting a bit with unsafe code both in the providers and in the vector/matrix data storage lately. While I prefer to keep the core library safe entirely, there's nothing wrong in providing an optional unsafe extension package. Of course to get full advantage here we'd also have to revise the array-based linear algebra provider interface.
redknightlois
In convolutional neural networks I work with huge ammount of data. With pointers is pretty easy to change the size of the array (using pointer arithmetics) in order to be able to partition the data.
Linear Algebra functionality doesnt support unchecked types so I have to first copy the relevant data to smaller buffers just for processing. We can agree that is a waste of resources ;).
A VectorView/MatrixView would allow to have the full support and at the same time being able to avoid unchecked types interfaces.