public override bool Execute(DotSpatial.Data.ICancelProgressHandler cancelProgressHandler)
{
var vec = GetVector(Matrix);
var var_name = GetName(Matrix);
if (vec != null)
{
if (Number <= 0)
{
Number = 10;
}
if (Number >= 100)
{
Number = 100;
}
var vec_name = "Histogram of " + GetName(Matrix);
cancelProgressHandler.Progress("Package_Tool", 10, "Calculating...");
var dou_vec = MatrixOperation.ToDouble(vec);
var hist = new Histogram(dou_vec, Number);
int nhist = hist.BucketCount;
int[] xx = new int[nhist];
int[] yy = new int[nhist];
for (int i = 0; i < nhist; i++)
{
xx[i] = (int)((hist[i].LowerBound + hist[i].UpperBound) * 0.5);
yy[i] = (int)hist[i].Count;
}
WorkspaceView.Plot <int>(xx, yy, vec_name, Models.UI.MySeriesChartType.Column);
return(true);
}
else
{
return(false);
}
}
public override bool Execute(DotSpatial.Data.ICancelProgressHandler cancelProgressHandler)
{
var vec = GetVector(Matrix);
if (vec != null)
{
var dou_vec = MatrixOperation.ToDouble(vec);
string vec_name = "CDF of " + GetName(Matrix);
int nlen = dou_vec.Length;
cancelProgressHandler.Progress("Package_Tool", 10, "Calculating...");
Array.Sort <double>(dou_vec);
var cdf = MathNet.Numerics.Statistics.Statistics.EmpiricalCDFFunc(dou_vec);
var cdf_value = new double[nlen];
for (int i = 0; i < nlen; i++)
{
cdf_value[i] = cdf(dou_vec[i]);
}
WorkspaceView.Plot <double>(dou_vec, cdf_value, vec_name, Models.UI.MySeriesChartType.FastLine);
return(true);
}
else
{
return(false);
}
}
public void ShowPreview(MatrixOperation operation)
{
foreach (MatrixItemUI item in itemUIs)
{
item.ShowPreview(operation);
}
}
/// <summary>
/// Summation matrix
/// </summary>
/// <param name="matrix1"></param>
/// <param name="matrix2"></param>
/// <param name="operation"></param>
/// <returns></returns>
public static int[,] SummationMatrix(int[,] matrix1, int[,] matrix2, MatrixOperation operation)
{
var n1 = matrix1.GetLength(0);
var m1 = matrix1.GetLength(1);
var n2 = matrix2.GetLength(0);
var m2 = matrix2.GetLength(1);
if (n1 != n2 || m1 != m2)
{
throw new Exception("Количество строк и столбцов в матрицах должно совпадать");
}
var resMatrix = new int[n1, m1];
for (int i = 0; i < n1; i++)
{
for (int j = 0; j < m1; j++)
{
if (operation == MatrixOperation.Plus)
{
resMatrix[i, j] = matrix1[i, j] + matrix2[i, j];
}
else
{
resMatrix[i, j] = matrix1[i, j] - matrix2[i, j];
}
}
}
return(resMatrix);
}
/// <summary>
/// Invert inplace - WARNING, use Solve for higher performance
/// </summary>
/// <param name="operation"></param>
public void Invert(MatrixOperation operation = MatrixOperation.None)
{
Debug.Assert(nRows == nCols);
Debug.Assert(Buffer.pointer != 0);
CuBlasApi.Invert(_buffer, operation);
}
/// <summary>
/// Solve A * X = B, B is overwritten
/// </summary>
/// <param name="rhs"></param>
/// <param name="lhsOperation"></param>
public void Solve(ColumnWiseMatrix rhs, MatrixOperation lhsOperation = MatrixOperation.None)
{
Debug.Assert(nRows == nCols);
Debug.Assert(Buffer.pointer != 0);
CuBlasApi.Solve(_buffer, rhs._buffer, lhsOperation);
}
/// <summary>
/// Same version as above, but gives the possibility of reusing the output buffer
/// </summary>
/// <param name="output"></param>
/// <param name="rhs"></param>
/// <param name="lhsOperation"></param>
/// <param name="rhsOperation"></param>
/// <param name="alpha"></param>
public void Multiply(ColumnWiseMatrix output, ColumnWiseMatrix rhs, MatrixOperation lhsOperation = MatrixOperation.None, MatrixOperation rhsOperation = MatrixOperation.None, double alpha = 1.0, double beta = 0.0)
{
if (lhsOperation == MatrixOperation.None)
{
Debug.Assert(rhs.nRows == nCols);
Debug.Assert(output.nRows == nRows);
Debug.Assert(output.nCols == rhs.nCols);
}
else
{
Debug.Assert(rhs.nCols == nCols);
Debug.Assert(output.nCols == nRows);
Debug.Assert(output.nRows == rhs.nCols);
}
Debug.Assert(memorySpace == rhs.memorySpace);
Debug.Assert(memorySpace == output.memorySpace);
Debug.Assert(mathDomain == rhs.mathDomain);
Debug.Assert(mathDomain == output.mathDomain);
Debug.Assert(Buffer.pointer != 0);
Debug.Assert(rhs.Buffer.pointer != 0);
Debug.Assert(output.Buffer.pointer != 0);
CuBlasApi.Multiply(output._buffer, _buffer, rhs._buffer, nRows, rhs.nRows, lhsOperation, rhsOperation, alpha, beta);
}
public void Sum_OperationPlusIsNotDefinedForType_TrowArgumentException()
{
SquareMatrix <object> matr = new SquareMatrix <object>(2, new object[] { new object() });
SquareMatrix <object> smatr = new SquareMatrix <object>(2, new object[] { new object() });
Assert.Throws <ArgumentException>(() => MatrixOperation.Sum <object>(matr, smatr));
}
private static MatrixPart Operation(MatrixPart first, MatrixPart second, MatrixOperation operation)
{
if (second == null || first == null)
{
throw new ArgumentException("Matrix shouldn't be null");
}
var mSizeFirst = MathExtensions.GetMatrixSize(first.Data);
var mSizeSecond = MathExtensions.GetMatrixSize(second.Data);
if (mSizeFirst.height != mSizeFirst.width || mSizeFirst.height != mSizeSecond.height || mSizeSecond.height != mSizeSecond.width)
{
throw new ArgumentException("Matrix should be square");
}
var result = new int[mSizeFirst.height, mSizeFirst.height];
for (var i = 0; i < mSizeFirst.height; i++)
{
for (var j = 0; j < mSizeFirst.height; j++)
{
if (operation == MatrixOperation.Summation)
{
result[i, j] = first.Data[i, j] + second.Data[i, j];
}
else
{
result[i, j] = first.Data[i, j] - second.Data[i, j];
}
}
}
return(new MatrixPart(result));
}
public void Sum_MatricesHaveDifferentSizes_TrowArgumentException()
{
SquareMatrix <int> matr = new SquareMatrix <int>(3, new int[] { 1 });
SquareMatrix <int> smatr = new SquareMatrix <int>(2, new int[] { 2 });
Assert.Throws <ArgumentException>(() => MatrixOperation.Sum <int>(matr, smatr));
}
/// <summary>
/// y = alpha * A * x + beta * y
/// </summary>
/// <param name="rhs"></param>
/// <param name="lhsOperation"></param>
/// <param name="alpha"></param>
/// <param name="beta"></param>
/// <returns></returns>
public Vector Dot(Vector rhs, MatrixOperation lhsOperation = MatrixOperation.None, double alpha = 1.0, double beta = 0.0)
{
Vector ret = new Vector(rhs.Size, memorySpace, rhs.mathDomain);
Dot(ret, rhs, lhsOperation, alpha, beta);
return(ret);
}
public Vector Dot(Vector rhs, MatrixOperation lhsOperation, double alpha)
{
Vector ret = new Vector(rhs.Size, memorySpace, rhs.mathDomain);
Dot(ret, rhs, lhsOperation, alpha);
return(ret);
}
/// <summary>
///
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="step"></param>
/// <param name="matrixOperation"></param>
private static void RunBenchmark(int start, int end, int step, MatrixOperation matrixOperation)
{
for (var i = start; i <= end; i += step)
{
Console.WriteLine("[" + i + "x" + i + "]");
matrixOperation(i, i);
}
}
public ColumnWiseMatrix Multiply(ColumnWiseMatrix rhs, MatrixOperation lhsOperation = MatrixOperation.None, MatrixOperation rhsOperation = MatrixOperation.None, double alpha = 1.0)
{
ColumnWiseMatrix ret = new ColumnWiseMatrix(nRows, rhs.nCols, memorySpace, rhs.mathDomain);
Multiply(ret, rhs, lhsOperation, rhsOperation, alpha);
return(ret);
}
// Operate on the matrix based on the matrix operation passed in
public Matrix Operate(MatrixOperation operation)
{
return(operation.type switch
{
MatrixOperation.Type.Swap => SwapRows(operation.sourceRow, operation.destinationRow),
MatrixOperation.Type.Scale => ScaleRow(operation.destinationRow, operation.scalar),
MatrixOperation.Type.Add => AddRowToRow(operation.sourceRow, operation.scalar, operation.destinationRow),
_ => this,
});
public static void AddEqualMatrix(MemoryTile A, MemoryTile B, MatrixOperation aOperation, MatrixOperation bOperation, double alpha, double beta)
{
int err = _AddEqualMatrixRaw(A.pointer, B.pointer, A.nRows, A.nCols, A.memorySpace, A.mathDomain, aOperation, bOperation, alpha, beta);
if (err != 0)
{
Exceptions.CuBlasKernelExceptionFactory.ThrowException("_AddEqualMatrixRaw", err);
}
}
public static void Invert(MemoryTile A, MatrixOperation aOperation)
{
int err = _InvertRaw(A.pointer, A.nRows, A.nCols, A.memorySpace, A.mathDomain, aOperation);
if (err != 0)
{
Exceptions.CuBlasKernelExceptionFactory.ThrowException("_InvertRaw", err);
}
}
public static void Dot(MemoryBuffer y, MemoryTile A, MemoryBuffer x, MatrixOperation aOperation, double alpha, double beta)
{
int err = _DotRaw(y.pointer, A.pointer, x.pointer, A.nRows, A.nCols, A.memorySpace, A.mathDomain, aOperation, alpha, beta);
if (err != 0)
{
Exceptions.CuBlasKernelExceptionFactory.ThrowException("_DotRaw", err);
}
}
public static double Cofactor(IMatrix a, MatrixOperation operationType, int r, int c)
{
double minorDeterminant = Determinant(Minor(a, r, c), operationType);
if (((r + c) & 1) == 1)
{
return(-minorDeterminant);
}
else
{
return(minorDeterminant);
}
}
public static IMatrix Invert(IMatrix a, MatrixOperation operationType)
{
switch (operationType)
{
case MatrixOperation.Cofactor:
return(InvertCofactor(a));
case MatrixOperation.Gauss:
return(InvertGauss(a));
default:
throw new NotSupportedException();
}
}
public void Setup(int rowIndex)
{
base.Start();
// Setup the operation source to request a row add operation
operationSource.Setup(() => MatrixOperation.RowAdd(rowIndex, -1, Scalar));
// Update display
UpdateDisplay();
// Listen for operation start-finish events on the matrix
MatrixParent.OnOperationStart.AddListener(OnMatrixOperationStarted);
MatrixParent.OnOperationFinish.AddListener(OnMatrixOperationFinished);
}
/// <summary>
/// Same version as above, but gives the possibility of reusing the output buffer
/// </summary>
/// <param name="output"></param>
/// <param name="rhs"></param>
/// <param name="lhsOperation"></param>
/// <param name="alpha"></param>
public void Dot(Vector output, Vector rhs, MatrixOperation lhsOperation = MatrixOperation.None, double alpha = 1.0)
{
Debug.Assert(rhs.Size == nCols);
Debug.Assert(output.Size == rhs.Size);
Debug.Assert(memorySpace == rhs.memorySpace);
Debug.Assert(memorySpace == output.memorySpace);
Debug.Assert(mathDomain == rhs.mathDomain);
Debug.Assert(mathDomain == output.mathDomain);
Debug.Assert(Buffer.pointer != 0);
Debug.Assert(rhs.Buffer.pointer != 0);
Debug.Assert(output.Buffer.pointer != 0);
CuSparseApi.SparseDot(output.Buffer, _buffer, rhs.Buffer, lhsOperation, alpha);
}
/// <summary>
/// Same version as above, but gives the possibility of reusing the output buffer
/// </summary>
/// <param name="output"></param>
/// <param name="rhs"></param>
/// <param name="lhsOperation"></param>
/// <param name="rhsOperation"></param>
/// <param name="alpha"></param>
public void Multiply(ColumnWiseMatrix output, ColumnWiseMatrix rhs, MatrixOperation lhsOperation = MatrixOperation.None, MatrixOperation rhsOperation = MatrixOperation.None, double alpha = 1.0)
{
Debug.Assert(rhs.nRows == nCols);
Debug.Assert(output.nRows == nRows);
Debug.Assert(output.nCols == rhs.nCols);
Debug.Assert(memorySpace == rhs.memorySpace);
Debug.Assert(memorySpace == output.memorySpace);
Debug.Assert(mathDomain == rhs.mathDomain);
Debug.Assert(mathDomain == output.mathDomain);
Debug.Assert(Buffer.pointer != 0);
Debug.Assert(rhs.Buffer.pointer != 0);
Debug.Assert(output.Buffer.pointer != 0);
CuSparseApi.SparseMultiply(output.Buffer as MemoryTile, _buffer, rhs.Buffer as MemoryTile, nRows, rhs.nRows, lhsOperation, rhsOperation, alpha);
}
public void Setup(int rowIndex)
{
Start();
this.rowIndex = rowIndex;
label.text = (rowIndex + 1).ToString();
// Listen for start and end of an operation
MatrixParent.OnOperationStart.AddListener(OnMatrixOperationStart);
MatrixParent.OnOperationFinish.AddListener(OnMatrixOperationFinish);
// Initialize the lsit of item uis
itemUIs = new MatrixItemUI[MatrixParent.CurrentMatrix.cols];
for (int j = 0; j < MatrixParent.CurrentMatrix.cols; j++)
{
MatrixItemUI itemUI = Instantiate(itemUIPrefab, rowRectTransform);
itemUI.Setup(this, j);
itemUIs[j] = itemUI;
}
// Setup the operation source to request a row swap when dragged
rowOperationSource.Setup(() => MatrixOperation.RowSwap(-1, rowIndex));
rowAddWidget.Setup(rowIndex);
// Setup the entry from on pointer enter
EventTrigger.Entry pointerEnter = new EventTrigger.Entry
{
eventID = EventTriggerType.PointerEnter,
callback = new EventTrigger.TriggerEvent()
};
pointerEnter.callback.AddListener(data => OnPointerEnter());
mouseDetector.triggers.Add(pointerEnter);
// Setup the entry from on pointer exit
EventTrigger.Entry pointerExit = new EventTrigger.Entry
{
eventID = EventTriggerType.PointerExit,
callback = new EventTrigger.TriggerEvent()
};
pointerExit.callback.AddListener(data => OnPointerExit());
mouseDetector.triggers.Add(pointerExit);
// Set non layout objects to last sibling
nonLayoutObjects.SetAsLastSibling();
}
public Func <Matrix, Matrix, Matrix> Resolve(MatrixOperation operationEnum)
{
switch (operationEnum)
{
case MatrixOperation.multiply:
return((a, b) => a * b);
case MatrixOperation.add:
return((a, b) => a + b);
case MatrixOperation.subtract:
return((a, b) => a - b);
default:
throw new ArgumentOutOfRangeException(nameof(operationEnum), operationEnum, null);
}
}
static void Main(string[] args)
{
Launcher launcher = new Launcher();
MatrixOparat.MatrixOperation matrix = new MatrixOperation();
launcher.ReadFile();
launcher.InitMatrix();
if (launcher.ValidateMatrixMultiplication())
{
double[,] res = matrix.Multiplication(launcher.matrixA.GetMatrix(), launcher.matrixB.GetMatrix());
Matrix.Print(res);
}
Console.ReadLine();
}
private void Solve(MatrixOperation operation, Matrix <T> m1, Matrix <T> m2, Matrix <T> m3, Matrix <T> result)
{
var trials = getTrials(m1.N, _numTrials);
var firstResult = new Matrix <T>(m1.M, m2.N);
var tasks = trials
.Select(trial => new TaskInfo(m1, m2, trial, firstResult))
.Select(taskInfo => new Task <Trials>(() => operation(taskInfo)))
.ToList();
var continuation = tasks.Select((task) =>
task.ContinueWith((t) => operation(new TaskInfo(firstResult, m3, t.Result, result)))).ToList();
tasks.ForEach((task) => task.Start());
Task.WaitAll(continuation.ToArray());
}
static void Main(string[] args)
{
int n = 10;
var matrix = new Matrix(n, n);
matrix.FillRandomly(0, 10);
MatrixOperation operation = matrix.DiagonalSum;
Console.WriteLine(operation());
operation = matrix.AvgSum;
Console.WriteLine(operation());
operation = matrix.SumSaddlePoints;
Console.WriteLine(operation());
Console.WriteLine(matrix);
Console.ReadKey();
}
public static double Determinant(IMatrix m, MatrixOperation operationType)
{
if (m.Rows != m.Columns)
{
throw new ArgumentException("Undetermined");
}
switch (operationType)
{
case MatrixOperation.Cofactor:
return(DeterminantWithCofactors(m));
case MatrixOperation.Gauss:
return(DeterminantWithGaussEliminitation(m));
default:
throw new NotSupportedException();
}
}
public DataCube <float> GetTimeSeries(int segIndex, int rchIndex, int varid, DateTime start)
{
DataCube <float> ts = null;
if (DataCube != null)
{
var scaleFactor = ScaleFactor;
var index = GetReachIndex(segIndex, rchIndex);
var vector = DataCube.GetVector(varid, ":", index.ToString());
DateTime[] dates = new DateTime[DataCube.Size[1]];
for (int t = 0; t < DataCube.Size[1]; t++)
{
dates[t] = start.AddDays(t);
}
MatrixOperation.Mulitple(vector, (float)scaleFactor);
ts = new DataCube <float>(vector, dates);
}
return(ts);
}
public float GetSlope(SectionPathLossCalcParam param, short[] altitudes, int nIndex)
{
int fNumber = (int) (param.MergeEdgeMaxDis / (4f * param.CalcResolution));
if (fNumber < 1)
{
fNumber = 1;
}
fNumber = Math.Min(this.Trim(fNumber, 5, 10), nIndex);
float[] a = new float[fNumber * 2];
float[] y = new float[fNumber];
int num2 = nIndex;
for (int i = 0; i < fNumber; i++)
{
a[i] = num2 * param.CalcResolution;
y[i] = altitudes[num2 - 1];
num2--;
}
float[] numArray3 = new float[2];
float[] numArray4 = new float[3];
LinearRegression regression = new LinearRegression();
MatrixOperation operation = new MatrixOperation();
regression.mvfitgn(a, y, numArray3, fNumber, 2, false);
return numArray3[1];
}
private ReturnValue Recursion(float[] valueMatrix, float[] actualLossMatrix, float[] coeMatrix, int validDataNumber, int coeNumNeedAdjust, bool isAdjustClutter)
{
ReturnValue value2 = ReturnValue.PROPADJ_SUCCESS;
if (coeNumNeedAdjust == 0)
{
return ReturnValue.PROPCOR_NOSUCESS;
}
if (validDataNumber < 10)
{
return ReturnValue.PROPCOR_LACKDATAERROR;
}
float[] numArray = new float[validDataNumber];
LinearRegression regression = new LinearRegression();
MatrixOperation operation = new MatrixOperation();
int num = 0;
try
{
num = regression.mvfitgn(valueMatrix, actualLossMatrix, coeMatrix, validDataNumber, coeNumNeedAdjust, isAdjustClutter);
}
catch (Exception exception)
{
WriteLog.Logger.Error(exception.StackTrace);
}
if (num != 0)
{
return ReturnValue.PROPCOR_NOTFIT;
}
return value2;
}
