public static MFullArray <TScalar> horzcat <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array1, MFullArray <TScalar> array2, MFullArray <TScalar> array3,
MFullArray <TScalar> array4, MFullArray <TScalar> array5, MFullArray <TScalar> array6,
MFullArray <TScalar> array7, MFullArray <TScalar> array8, MFullArray <TScalar> array9,
MFullArray <TScalar> array10, MFullArray <TScalar> array11, MFullArray <TScalar> array12,
MFullArray <TScalar> array13, MFullArray <TScalar> array14, MFullArray <TScalar> array15,
MFullArray <TScalar> array16, MFullArray <TScalar> array17, MFullArray <TScalar> array18,
MFullArray <TScalar> array19, MFullArray <TScalar> array20, MFullArray <TScalar> array21,
MFullArray <TScalar> array22, MFullArray <TScalar> array23, MFullArray <TScalar> array24,
MFullArray <TScalar> array25, MFullArray <TScalar> array26, MFullArray <TScalar> array27,
MFullArray <TScalar> array28, MFullArray <TScalar> array29, MFullArray <TScalar> array30,
MFullArray <TScalar> array31, MFullArray <TScalar> array32, MFullArray <TScalar> array33,
MFullArray <TScalar> array34, MFullArray <TScalar> array35, MFullArray <TScalar> array36,
MFullArray <TScalar> array37, MFullArray <TScalar> array38, MFullArray <TScalar> array39,
MFullArray <TScalar> array40, MFullArray <TScalar> array41, MFullArray <TScalar> array42,
MFullArray <TScalar> array43, MFullArray <TScalar> array44, MFullArray <TScalar> array45,
MFullArray <TScalar> array46, MFullArray <TScalar> array47, MFullArray <TScalar> array48,
MFullArray <TScalar> array49, MFullArray <TScalar> array50, MFullArray <TScalar> array51,
MFullArray <TScalar> array52, MFullArray <TScalar> array53, MFullArray <TScalar> array54,
MFullArray <TScalar> array55, MFullArray <TScalar> array56)
{
return(horzcat(new[]
{
array1, array2, array3, array4, array5, array6, array7, array8, array9, array10,
array11, array12, array13, array14, array15, array16, array17, array18, array19, array20,
array21, array22, array23, array24, array25, array26, array27, array28, array29, array30,
array31, array32, array33, array34, array35, array36, array37, array38, array39, array40,
array41, array42, array43, array44, array45, array46, array47, array48, array49, array50,
array51, array52, array53, array54, array55, array56
}));
}
public static MFullArray <double> max(MFullArray <double> array)
{
Contract.Requires(array != null);
var shape = array.Shape;
int dimensionIndex = shape.IndexOfFirstNonSingletonDimension();
int sliceStep, sliceSize;
shape.GetDimensionStepAndSize(dimensionIndex, out sliceStep, out sliceSize);
var result = new MFullArray <double>(MArrayShape.CollapseDimension(shape, dimensionIndex));
var resultArray = result.BackingArray;
for (int sliceIndex = 0; sliceIndex < resultArray.Length; ++sliceIndex)
{
double maximum = double.NegativeInfinity;
for (int sliceElementIndex = 0; sliceElementIndex < sliceSize; ++sliceElementIndex)
{
double value = array[sliceIndex * sliceSize + sliceElementIndex * sliceStep];
if (value > maximum)
{
maximum = value;
}
}
resultArray[sliceIndex] = maximum;
}
return(result);
}
public static MFullArray <double> mean(MFullArray <double> array)
{
Contract.Requires(array != null);
var shape = array.Shape;
int dimensionIndex = shape.IndexOfFirstNonSingletonDimension();
int sliceStep, sliceSize;
shape.GetDimensionStepAndSize(dimensionIndex, out sliceStep, out sliceSize);
var result = new MFullArray <double>(MArrayShape.CollapseDimension(shape, dimensionIndex));
var resultArray = result.BackingArray;
for (int sliceIndex = 0; sliceIndex < resultArray.Length; ++sliceIndex)
{
double sum = 0;
for (int sliceElementIndex = 0; sliceElementIndex < sliceSize; ++sliceElementIndex)
{
sum += array[sliceIndex * sliceSize + sliceElementIndex * sliceStep];
}
resultArray[sliceIndex] = sum / sliceSize;
}
return(result);
}
public static MFullArray <double> rdivide(MFullArray <double> lhs, MFullArray <double> rhs)
{
Contract.Requires(lhs != null);
Contract.Requires(rhs != null);
if (lhs.IsScalar)
{
return(rdivide(lhs[0], rhs));
}
if (rhs.IsScalar)
{
return(rdivide(lhs, rhs[0]));
}
if (lhs.Shape != rhs.Shape)
{
throw new MArrayShapeException();
}
var result = new MFullArray <double>(lhs.Shape);
for (int i = 0; i < lhs.Count; ++i)
{
result[i] = lhs[i] / rhs[i];
}
return(result);
}
public static MFullArray <double> minus(MFullArray <double> lhs, MFullArray <double> rhs)
{
Contract.Requires(lhs != null);
Contract.Requires(rhs != null);
if (lhs.IsScalar)
{
return(minus(lhs[0], rhs));
}
if (rhs.IsScalar)
{
return(minus(lhs, rhs[0]));
}
if (lhs.Shape != rhs.Shape)
{
throw new MArrayShapeException();
}
var c = new MFullArray <double>(lhs.Shape);
for (int i = 0; i < lhs.Count; ++i)
{
c[i] = lhs[i] - rhs[i];
}
return(c);
}
private static MFullArray <TScalar> vertcat <[AnyPrimitive] TScalar>(params MFullArray <TScalar>[] arrays)
{
Contract.Requires(arrays != null);
Contract.Requires(arrays.Length > 0);
int columnCount = arrays[0].ColumnCount;
int totalRowCount = 0;
foreach (var array in arrays)
{
if (array.IsHigherDimensional)
{
throw new NotImplementedException("vertcat on higher-dimensional arrays.");
}
totalRowCount += array.RowCount;
}
var result = new MFullArray <TScalar>(totalRowCount, columnCount);
int baseRowIndex = 0;
foreach (var array in arrays)
{
int arrayRowCount = array.RowCount;
for (int i = 0; i < arrayRowCount; ++i)
{
for (int j = 0; j < columnCount; ++j)
{
result[j * totalRowCount + baseRowIndex + i] = array[j * arrayRowCount + i];
}
}
baseRowIndex += arrayRowCount;
}
return(result);
}
public static MFullArray <TScalar> horzcat <[AnyPrimitive] TScalar>(MFullArray <TScalar> left, MFullArray <TScalar> right)
{
Contract.Requires(left != null);
Contract.Requires(right != null);
if (left.IsHigherDimensional || right.IsHigherDimensional)
{
throw new NotImplementedException("horzcat on higher-dimensional arrays.");
}
if (left.RowCount != right.RowCount)
{
throw new MArrayShapeException();
}
int rowCount = left.RowCount;
var resultShape = new MArrayShape(rowCount, left.ColumnCount + right.ColumnCount);
var result = new MFullArray <TScalar>(resultShape);
for (int rowIndex = 0; rowIndex < rowCount; ++rowIndex)
{
for (int leftColumnIndex = 0; leftColumnIndex < left.ColumnCount; ++leftColumnIndex)
{
result[leftColumnIndex * rowCount + rowIndex] = left[leftColumnIndex * rowCount + rowIndex];
}
for (int rightColumnIndex = 0; rightColumnIndex < right.ColumnCount; ++rightColumnIndex)
{
result[(left.ColumnCount + rightColumnIndex) * rowCount + rowIndex] = right[rightColumnIndex * rowCount + rowIndex];
}
}
return(result);
}
public static MFullArray <bool> all(MFullArray <bool> array)
{
Contract.Requires(array != null);
if (array.IsEmpty)
{
return(true);
}
var shape = array.Shape;
int dimensionIndex = shape.IndexOfFirstNonSingletonDimension();
int sliceStep, sliceSize;
shape.GetDimensionStepAndSize(dimensionIndex, out sliceStep, out sliceSize);
var result = new MFullArray <bool>(MArrayShape.CollapseDimension(shape, dimensionIndex));
var resultArray = result.BackingArray;
for (int sliceIndex = 0; sliceIndex < resultArray.Length; ++sliceIndex)
{
bool value = true;
for (int sliceElementIndex = 0; sliceElementIndex < sliceSize; ++sliceElementIndex)
{
value &= array[sliceIndex * sliceSize + sliceElementIndex * sliceStep];
}
resultArray[sliceIndex] = value;
}
return(result);
}
public static MFullArray <double> ldivide(MFullArray <double> lhs, MFullArray <double> rhs)
{
Contract.Requires(lhs != null);
Contract.Requires(rhs != null);
return(rdivide(rhs, lhs));
}
public static MFullArray <double> clock()
{
var now = DateTime.Now;
return(MFullArray <double> .CreateRowVector(
now.Year, now.Month, now.Day,
now.Hour, now.Minute, now.Second + now.Millisecond / 1000.0));
}
public static MFullArray <double> rem(MFullArray <double> lhs, MFullArray <double> rhs)
{
Contract.Requires(lhs != null);
Contract.Requires(rhs != null);
MatchShapes(ref lhs, ref rhs);
return(MFunctional.Map(lhs, rhs, rem));
}
public static MFullArray <bool> any(MFullArray <double> array)
{
Contract.Requires(array != null);
if (array.IsEmpty)
{
return(false);
}
return(MFunctional.CollapseDimension(array, d => d != 0, (b1, b2) => b1 | b2));
}
public static MFullArray <TScalar> horzcat <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array1, MFullArray <TScalar> array2, MFullArray <TScalar> array3,
MFullArray <TScalar> array4, MFullArray <TScalar> array5, MFullArray <TScalar> array6,
MFullArray <TScalar> array7, MFullArray <TScalar> array8, MFullArray <TScalar> array9,
MFullArray <TScalar> array10, MFullArray <TScalar> array11, MFullArray <TScalar> array12,
MFullArray <TScalar> array13, MFullArray <TScalar> array14)
{
return(horzcat(new[] { array1, array2, array3, array4, array5, array6, array7, array8, array9, array10, array11, array12, array13, array14 }));
}
public static MFullArray <bool> not(MFullArray <bool> array)
{
Contract.Requires(array != null);
if (array.IsScalar)
{
return(not(array[0]));
}
return(MFunctional.Map(array, not));
}
public static MFullArray <double> hypot(MFullArray <double> x, MFullArray <double> y)
{
ElementaryOperations.MatchShapes(ref x, ref y);
var result = new MFullArray <double>(x.Shape);
for (int i = 0; i < result.Count; ++i)
{
result[i] = Math.Sqrt(x[i] * x[i] + y[i] * y[i]);
}
return(result);
}
public static MFullArray <double> power(double @base, MFullArray <double> exponent)
{
Contract.Requires(exponent != null);
var result = new MFullArray <double>(exponent.Shape);
for (int i = 0; i < exponent.Count; ++i)
{
result[i] = power(@base, exponent[i]);
}
return(result);
}
public static MFullArray <bool> le(MFullArray <double> a, MFullArray <double> b)
{
ElementaryOperations.MatchShapes(ref a, ref b);
var result = new MFullArray <bool>(a.Shape);
for (int i = 0; i < result.Count; ++i)
{
result[i] = a[i] <= b[i];
}
return(result);
}
public static MFullArray <double> minus(double lhs, MFullArray <double> rhs)
{
Contract.Requires(rhs != null);
var c = new MFullArray <double>(rhs.Shape);
for (int i = 0; i < rhs.Count; ++i)
{
c[i] = lhs - rhs[i];
}
return(c);
}
public static MFullArray <double> rdivide(double lhs, MFullArray <double> rhs)
{
Contract.Requires(rhs != null);
var result = new MFullArray <double>(rhs.Shape);
for (int i = 0; i < rhs.Count; ++i)
{
result[i] = lhs / rhs[i];
}
return(result);
}
public static MFullArray <double> fix(MFullArray <double> array)
{
Contract.Requires(array != null);
var result = new MFullArray <double>(array.Shape);
for (int i = 0; i < result.Count; ++i)
{
result[i] = fix(array[i]);
}
return(result);
}
public static MFullArray <double> power(MFullArray <double> @base, double exponent)
{
Contract.Requires(@base != null);
var result = new MFullArray <double>(@base.Shape);
for (int i = 0; i < @base.Count; ++i)
{
result[i] = power(@base[i], exponent);
}
return(result);
}
public static MFullArray <double> plus(MFullArray <double> lhs, double rhs)
{
Contract.Requires(lhs != null);
var c = new MFullArray <double>(lhs.Shape);
for (int i = 0; i < lhs.Count; ++i)
{
c[i] = lhs[i] + rhs;
}
return(c);
}
public static MFullArray <bool> isnan(MFullArray <double> array)
{
Contract.Requires(array != null);
var result = new MFullArray <bool>(array.Shape);
for (int i = 0; i < array.Count; ++i)
{
result[i] = double.IsNaN(array[i]);
}
return(result);
}
public static MFullArray <TReal> imag <[AnyReal] TReal>(MFullArray <MComplex <TReal> > array) where TReal : struct
{
Contract.Requires(array != null);
var result = new MFullArray <TReal>(array.Shape);
for (int i = 0; i < array.Count; ++i)
{
result[i] = array[i].ImaginaryPart;
}
return(result);
}
internal static DateTime RowToDateTime(MFullArray <double> array, int rowIndex)
{
int rowCount = array.Shape.RowCount;
double seconds = array[rowCount * 5 + rowIndex];
return(new DateTime(
PseudoBuiltins.ToInt(array[rowCount * 0 + rowIndex]),
PseudoBuiltins.ToInt(array[rowCount * 1 + rowIndex]),
PseudoBuiltins.ToInt(array[rowCount * 2 + rowIndex]),
PseudoBuiltins.ToInt(array[rowCount * 3 + rowIndex]),
PseudoBuiltins.ToInt(array[rowCount * 4 + rowIndex]),
(int)seconds, (int)((seconds % 1) * 1000)));
}
public static MFullArray <double> size(MValue value)
{
Contract.Requires(value != null);
var shape = value.Shape;
var result = new MFullArray <double>(MArrayShape.RowVector(shape.DimensionCount));
for (int i = 0; i < shape.DimensionCount; ++i)
{
result[i] = shape.GetDimensionSize(i);
}
return(result);
}
public static MFullArray <double> times(MFullArray <double> lhs, double rhs)
{
Contract.Requires(lhs != null);
var result = new MFullArray <double>(lhs.Shape);
var lhsArray = lhs.BackingArray;
var resultArray = result.BackingArray;
int count = lhs.Count;
for (int i = 0; i < count; ++i)
{
resultArray[i] = lhsArray[i] * rhs;
}
return(result);
}
public static MFullArray <double> mpower(MFullArray <double> @base, double exponent)
{
Contract.Requires(@base != null);
if ([email protected])
{
throw new MArrayShapeException();
}
if (@base.IsScalar)
{
return(mpower(@base[0], exponent));
}
throw new NotImplementedException("Non-scalar mpower.");
}
public static double norm(MFullArray <double> array)
{
Contract.Requires(array != null);
if (array.IsVector)
{
double norm = 0;
for (int i = 0; i < array.Count; ++i)
{
norm += array[i] * array[i];
}
return(ExponentsAndLogarithms.sqrt(norm));
}
throw new NotImplementedException("Matrix 2-norm.");
}
public static MFullArray <double> randi(double imax, double rowCount, double columnCount)
{
var exclusiveMax = PseudoBuiltins.ToInt(imax + 1);
var result = MFullArray <double> .CreateWithShape(rowCount, columnCount);
int count = result.Count;
lock (threadSharedRandom)
{
for (int i = 0; i < count; ++i)
{
result.BackingArray[i] = threadSharedRandom.Next(0, exclusiveMax);
}
}
return(result);
}
