public FloatArraySliceObj(PaddedFloatArray source, double[] elts, int offset, int len)
{
data = SeqObjData((uint)len);
extraData = NeSeqObjExtraData();
this.elts = elts;
this.offset = offset;
this.source = source;
}
//////////////////////////////////////////////////////////////////////////////
public static FloatArraySliceObj Create(double value)
{
double[] buffer = new double[32];
buffer[0] = value;
PaddedFloatArray paddedArray = new PaddedFloatArray(buffer, 1);
return(paddedArray.Slice(0, 1));
}
public static FloatArraySliceObj Create(NeFloatSeqObj seq, double value)
{
int len = seq.GetSize();
int size = MinBufferSize(len + 1);
double[] buffer = new double[size];
seq.Copy(0, len, buffer, 0);
buffer[len] = value;
PaddedFloatArray paddedArray = new PaddedFloatArray(buffer, len + 1);
return(paddedArray.Slice(0, len + 1));
}
public static FloatArraySliceObj Create(NeFloatSeqObj left, NeFloatSeqObj right)
{
int leftLen = left.GetSize();
int rightLen = right.GetSize();
int len = leftLen + rightLen;
int size = MinBufferSize(len);
double[] buffer = new double[size];
left.Copy(0, leftLen, buffer, 0);
right.Copy(0, rightLen, buffer, leftLen);
PaddedFloatArray paddedArray = new PaddedFloatArray(buffer, len);
return(paddedArray.Slice(0, len));
}
public /*synchronized*/ FloatArraySliceObj Concat(int idx, NeFloatSeqObj seq)
{
int seqLen = seq.GetSize();
int newLen = idx + seqLen;
if (newLen > buffer.Length)
{
// We run out of space, expanding the array buffer
int size = MinBufferSize(newLen);
double[] newBuffer = new double[size];
for (int i = 0; i < idx; i++)
{
newBuffer[i] = buffer[i];
}
seq.Copy(0, seqLen, newBuffer, idx);
PaddedFloatArray newArray = new PaddedFloatArray(newBuffer, newLen);
return(newArray.Slice(0, newLen));
//## THINK ABOUT THIS. WOULD IT WORK?
// buffer = newBuffer;
// used = newLen;
// return new FloatArraySliceObj(this, buffer, 0, used);
}
else if (idx == used)
{
// There's space for the new elements
seq.Copy(0, seqLen, buffer, idx);
used = newLen;
return(new FloatArraySliceObj(this, buffer, 0, used));
}
else
{
// The next slot was already taken. This is supposed to happen only rarely
Debug.Assert(idx < used & idx < buffer.Length);
double[] newBuffer = new double[buffer.Length];
for (int i = 0; i < idx; i++)
{
newBuffer[i] = buffer[i];
}
seq.Copy(0, seqLen, newBuffer, idx);
PaddedFloatArray newArray = new PaddedFloatArray(newBuffer, newLen);
return(newArray.Slice(0, newLen));
}
}
public /*synchronized*/ FloatArraySliceObj Append(int idx, double value)
{
if (idx == buffer.Length)
{
// We run out of space, expanding the array buffer
int size = buffer.Length;
int newSize = 2 * size;
double[] newBuffer = new double[newSize];
for (int i = 0; i < size; i++)
{
newBuffer[i] = buffer[i];
}
newBuffer[idx] = value;
PaddedFloatArray newArray = new PaddedFloatArray(newBuffer, idx + 1);
return(newArray.Slice(0, idx + 1));
//## THINK ABOUT THIS. WOULD IT WORK?
// buffer = newBuffer;
// used++;
// return new FloatArraySliceObj(this, buffer, 0, used);
}
else if (idx == used)
{
// There's space for the new element
buffer[idx] = value;
used++;
return(new FloatArraySliceObj(this, buffer, 0, used));
}
else
{
// The next slot was already taken. This is supposed to happen only rarely
Debug.Assert(idx < used & idx < buffer.Length);
double[] newBuffer = new double[buffer.Length];
for (int i = 0; i < idx; i++)
{
newBuffer[i] = buffer[i];
}
newBuffer[idx] = value;
PaddedFloatArray newArray = new PaddedFloatArray(newBuffer, idx + 1);
return(newArray.Slice(0, idx + 1));
}
}
internal static FloatArraySliceObj Concat(NeFloatSeqObj left, NeFloatSeqObj right)
{
return(PaddedFloatArray.Create(left, right));
}
internal static FloatArraySliceObj Append(NeFloatSeqObj seq, double value)
{
return(PaddedFloatArray.Create(seq, value));
}
internal static NeSeqObj CreateRightPadded(double value)
{
return(PaddedFloatArray.Create(value));
}
