private DataElement ContinueReadingStructure(
BinaryReader reader,
ArrayFlags flags,
int[] dimensions,
string name,
int fieldNameLength)
{
var element = Read(reader);
var fieldNames = ReadFieldNames(element as MiNum <sbyte>, fieldNameLength);
var fields = new Dictionary <string, List <IArray> >();
foreach (var fieldName in fieldNames)
{
fields[fieldName] = new List <IArray>();
}
var numberOfElements = dimensions.NumberOfElements();
for (var i = 0; i < numberOfElements; i++)
{
foreach (var fieldName in fieldNames)
{
var field = Read(reader) as IArray;
fields[fieldName].Add(field);
}
}
return(new MatStructureArray(flags, dimensions, name, fields));
}
/// <summary>
/// Construct a numerical array.
/// </summary>
/// <typeparam name="T">Element type.</typeparam>
/// <param name="flags">Array flags.</param>
/// <param name="dimensions">Array dimensions.</param>
/// <param name="name">Array name.</param>
/// <param name="realData">Real parts of the values.</param>
/// <param name="imaginaryData">Imaginary parts of the values.</param>
/// <returns>A constructed array.</returns>
/// <remarks>
/// Possible values for T: Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double,
/// ComplexOf<TReal> (where TReal is one of Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single),
/// Complex.
/// </remarks>
public static MatArray ConvertToMatNumericalArrayOf <T>(
ArrayFlags flags,
int[] dimensions,
string name,
DataElement realData,
DataElement imaginaryData)
where T : struct
{
if (flags.Variable.HasFlag(Variable.IsLogical))
{
var data = DataExtraction.GetDataAsUInt8(realData).ToArrayLazily().Select(x => x != 0).ToArray();
return(new MatNumericalArrayOf <bool>(flags, dimensions, name, data));
}
switch (flags.Class)
{
case ArrayType.MxChar:
switch (realData)
{
case MiNum <byte> dataByte:
return(ConvertToMatCharArray(flags, dimensions, name, dataByte));
case MiNum <ushort> dataUshort:
return(ConvertToMatCharArray(flags, dimensions, name, dataUshort));
default:
throw new NotSupportedException("Only utf8, utf16 or ushort char arrays are supported.");
}
case ArrayType.MxDouble:
case ArrayType.MxSingle:
case ArrayType.MxInt8:
case ArrayType.MxUInt8:
case ArrayType.MxInt16:
case ArrayType.MxUInt16:
case ArrayType.MxInt32:
case ArrayType.MxUInt32:
case ArrayType.MxInt64:
case ArrayType.MxUInt64:
var dataArray = ConvertDataToProperType <T>(realData, flags.Class);
if (flags.Variable.HasFlag(Variable.IsComplex))
{
var dataArray2 = ConvertDataToProperType <T>(imaginaryData, flags.Class);
if (flags.Class == ArrayType.MxDouble)
{
var complexArray =
(dataArray as double[])
.Zip(dataArray2 as double[], (x, y) => new Complex(x, y))
.ToArray();
return(new MatNumericalArrayOf <Complex>(flags, dimensions, name, complexArray));
}
var complexDataArray = dataArray.Zip(dataArray2, (x, y) => new ComplexOf <T>(x, y)).ToArray();
return(new MatNumericalArrayOf <ComplexOf <T> >(flags, dimensions, name, complexDataArray));
}
return(new MatNumericalArrayOf <T>(flags, dimensions, name, dataArray));
default:
throw new NotSupportedException();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MatStructureArray"/> class.
/// </summary>
/// <param name="flags">Array properties.</param>
/// <param name="dimensions">Dimensions of the array.</param>
/// <param name="name">Array name.</param>
/// <param name="fields">Array contents.</param>
public MatStructureArray(
ArrayFlags flags,
int[] dimensions,
string name,
Dictionary <string, List <IArray> > fields)
: base(flags, dimensions, name)
{
Fields = fields;
}
/// <summary>
/// Initializes a new instance of the <see cref="MatArray"/> class.
/// </summary>
/// <param name="flags">Array properties.</param>
/// <param name="dimensions">Dimensions of the array.</param>
/// <param name="name">Array name.</param>
protected MatArray(
ArrayFlags flags,
int[] dimensions,
string name)
{
Flags = flags;
Dimensions = dimensions;
Name = name;
}
private static MatCharArrayOf <byte> ConvertToMatCharArray(
ArrayFlags flags,
int[] dimensions,
string name,
MiNum <byte> dataElement)
{
var data = dataElement.Data;
return(new MatCharArrayOf <byte>(flags, dimensions, name, data, Encoding.UTF8.GetString(data)));
}
private static MatCharArrayOf <ushort> ConvertToMatCharArray(
ArrayFlags flags,
int[] dimensions,
string name,
MiNum <ushort> dataElement)
{
var data = dataElement.Data;
return(new MatCharArrayOf <ushort>(
flags,
dimensions,
name,
data,
new string(data.Select(x => (char)x).ToArray())));
}
private DataElement ContinueReadingCellArray(
BinaryReader reader,
ArrayFlags flags,
int[] dimensions,
string name)
{
var numberOfElements = dimensions.NumberOfElements();
var elements = new List <IArray>();
for (var i = 0; i < numberOfElements; i++)
{
var element = Read(reader) as IArray;
elements.Add(element);
}
return(new MatCellArray(flags, dimensions, name, elements));
}
/// <summary>
/// Initializes a new instance of the <see cref="MatNumericalArrayOf{T}"/> class.
/// </summary>
/// <param name="flags">Array parameters.</param>
/// <param name="dimensions">Dimensions of the array.</param>
/// <param name="name">Array name.</param>
/// <param name="data">Array contents.</param>
public MatNumericalArrayOf(ArrayFlags flags, int[] dimensions, string name, T[] data)
: base(flags, dimensions, name)
{
Data = data;
}
/// <summary>
/// Initializes a new instance of the <see cref="MatCellArray"/> class.
/// </summary>
/// <param name="flags">Array properties.</param>
/// <param name="dimensions">Dimensions of the array.</param>
/// <param name="name">Array name.</param>
/// <param name="elements">Array elements.</param>
public MatCellArray(ArrayFlags flags, int[] dimensions, string name, IEnumerable <IArray> elements)
: base(flags, dimensions, name)
{
Data = elements.ToArray();
}
